Moved around more code. Implemented more sqlc. Added support to generate swagger.

Added support for profiling. Removed the pkg module altogether.
Everything except old sync is now using code generated by sqlc.

internal/backend/music.go

@@ -3,17 +3,48 @@ package backend
 import (
 	"log"
 	"math/rand"
-	"music-server/pkg/db"
-	"music-server/pkg/models"
+	"music-server/internal/db"
+	"music-server/internal/db/repository"
 	"os"
 	"strconv"
 	"strings"
 )
 
+type SongInfo struct {
+	Game             string `json:"Game"`
+	GamePlayed       int32  `json:"GamePlayed"`
+	Song             string `json:"Song"`
+	SongPlayed       int32  `json:"SongPlayed"`
+	CurrentlyPlaying bool   `json:"CurrentlyPlaying"`
+	SongNo           int    `json:"SongNo"`
+}
+
 var currentSong = -1
-var games []models.GameData
-var songQue []models.SongData
-var lastFetched models.SongData
+
+// var games []models.GameData
+var gamesNew []repository.Game
+
+// var songQue []models.SongData
+var songQueNew []repository.Song
+
+// var lastFetched models.SongData
+var lastFetchedNew repository.Song
+var repo *repository.Queries
+
+func initRepo() {
+	if repo == nil {
+		repo = repository.New(db.Dbpool)
+	}
+}
+
+func getAllGames() []repository.Game {
+	if len(gamesNew) == 0 {
+		initRepo()
+		gamesNew, _ = repo.FindAllGames(db.Ctx)
+	}
+	return gamesNew
+
+}
 
 func GetSoundCheckSong() string {
 	files, err := os.ReadDir("songs")
@@ -25,105 +56,125 @@ func GetSoundCheckSong() string {
 }
 
 func Reset() {
-	songQue = nil
+	songQueNew = nil
 	currentSong = -1
-	games = db.FindAllGames()
+	initRepo()
+	gamesNew, _ = repo.FindAllGames(db.Ctx)
+	//games = db.FindAllGames()
 }
 
 func AddLatestToQue() {
-	if lastFetched.Path != "" {
-		currentSong = len(songQue)
-		songQue = append(songQue, lastFetched)
-		lastFetched = models.SongData{}
+	if lastFetchedNew.Path != "" {
+		currentSong = len(songQueNew)
+		songQueNew = append(songQueNew, lastFetchedNew)
+		lastFetchedNew = repository.Song{}
 	}
 }
 
 func AddLatestPlayed() {
-	if len(songQue) == 0 {
+	if len(songQueNew) == 0 {
 		return
 	}
-	var currentSongData = songQue[currentSong]
+	currentSongData := songQueNew[currentSong]
 
-	db.AddGamePlayed(currentSongData.GameId)
-	db.AddSongPlayed(currentSongData.GameId, currentSongData.SongName)
+	initRepo()
+	repo.AddGamePlayed(db.Ctx, currentSongData.GameID)
+	repo.AddSongPlayed(db.Ctx, repository.AddSongPlayedParams{GameID: currentSongData.GameID, SongName: currentSongData.SongName})
+	//db.AddGamePlayed(currentSongData.GameId)
+	//db.AddSongPlayed(currentSongData.GameId, currentSongData.SongName)
 }
 
 func SetPlayed(songNumber int) {
-	if len(songQue) == 0 || songNumber >= len(songQue) {
+	if len(songQueNew) == 0 || songNumber >= len(songQueNew) {
 		return
 	}
-	var songData = songQue[songNumber]
-	db.AddGamePlayed(songData.GameId)
-	db.AddSongPlayed(songData.GameId, songData.SongName)
+	songData := songQueNew[songNumber]
+	initRepo()
+	repo.AddGamePlayed(db.Ctx, songData.GameID)
+	repo.AddSongPlayed(db.Ctx, repository.AddSongPlayedParams{GameID: songData.GameID, SongName: songData.SongName})
+	//db.AddGamePlayed(songData.GameId)
+	//db.AddSongPlayed(songData.GameId, songData.SongName)
 }
 
 func GetRandomSong() string {
-	if len(games) == 0 {
+	/*if len(games) == 0 {
 		games = db.FindAllGames()
-	}
-	if len(games) == 0 {
+	}*/
+	getAllGames()
+	if len(gamesNew) == 0 {
 		return ""
 	}
 
-	song := getSongFromList(games)
-	lastFetched = song
+	song := getSongFromList(gamesNew)
+	lastFetchedNew = song
 	return song.Path
 }
 
 func GetRandomSongLowChance() string {
-	if len(games) == 0 {
+	/*if len(games) == 0 {
 		games = db.FindAllGames()
-	}
+	}*/
+	getAllGames()
 
-	var listOfGames []models.GameData
+	//var listOfGames []models.GameData
+	var listOfGames []repository.Game
 
-	var averagePlayed = getAveragePlayed(games)
+	var averagePlayed = getAveragePlayed()
 
-	for _, data := range games {
-		var timesToAdd = averagePlayed - data.TimesPlayed
+	for _, data := range gamesNew {
+		timesToAdd := averagePlayed - data.TimesPlayed
 		if timesToAdd <= 0 {
 			listOfGames = append(listOfGames, data)
 		} else {
-			for i := 0; i < timesToAdd; i++ {
+			for i := int32(0); i < timesToAdd; i++ {
 				listOfGames = append(listOfGames, data)
 			}
 		}
 	}
 	song := getSongFromList(listOfGames)
 
-	lastFetched = song
+	lastFetchedNew = song
 	return song.Path
 
 }
 
 func GetRandomSongClassic() string {
-	if games == nil || len(games) == 0 {
+	/*if games == nil || len(games) == 0 {
 		games = db.FindAllGames()
-	}
+	}*/
 
-	var listOfAllSongs []models.SongData
-	for _, game := range games {
-		listOfAllSongs = append(listOfAllSongs, db.FindSongsFromGame(game.Id)...)
+	getAllGames()
+
+	var listOfAllSongs []repository.Song
+	for _, game := range gamesNew {
+		//listOfAllSongs = append(listOfAllSongs, db.FindSongsFromGame(game.Id)...)
+		songList, _ := repo.FindSongsFromGame(db.Ctx, game.ID)
+		listOfAllSongs = append(listOfAllSongs, songList...)
 	}
 
 	songFound := false
-	var song models.SongData
+	var song repository.Song
 	for !songFound {
 		song = listOfAllSongs[rand.Intn(len(listOfAllSongs))]
-		gameData, err := db.GetGameById(song.GameId)
+		//gameData, err := db.GetGameById(song.GameId)
+		gameData, err := repo.GetGameById(db.Ctx, song.GameID)
 
 		if err != nil {
-			db.RemoveBrokenSong(song)
-			log.Println("Song not found, song '" + song.SongName + "' deleted from game '" + gameData.GameName + "' FileName: " + song.FileName)
+			//db.RemoveBrokenSong(song)
+			repo.RemoveBrokenSong(db.Ctx, song.Path)
+			//log.Println("Song not found, song '" + song.SongName + "' deleted from game '" + gameData.GameName + "' FileName: " + song.FileName)
+			log.Printf("Song not found, song '%s' deleted from game '%s' FileName: %v\n", song.SongName, gameData.GameName, song.FileName)
 			continue
 		}
 
 		//Check if file exists and open
 		openFile, err := os.Open(song.Path)
-		if err != nil || gameData.Path+song.FileName != song.Path {
+		if err != nil || (song.FileName != nil && gameData.Path+*song.FileName != song.Path) {
 			//File not found
-			db.RemoveBrokenSong(song)
-			log.Println("Song not found, song '" + song.SongName + "' deleted from game '" + gameData.GameName + "' FileName: " + song.FileName)
+			//db.RemoveBrokenSong(song)
+			repo.RemoveBrokenSong(db.Ctx, song.Path)
+			//log.Println("Song not found, song '" + song.SongName + "' deleted from game '" + gameData.GameName + "' FileName: " + song.FileName)
+			log.Printf("Song not found, song '%s' deleted from game '%s' FileName: %v\n", song.SongName, gameData.GameName, song.FileName)
 		} else {
 			songFound = true
 		}
@@ -132,19 +183,19 @@ func GetRandomSongClassic() string {
 			log.Println(err)
 		}
 	}
-	lastFetched = song
+	lastFetchedNew = song
 	return song.Path
 }
 
-func GetSongInfo() models.SongInfo {
-	if songQue == nil {
-		return models.SongInfo{}
+func GetSongInfo() SongInfo {
+	if songQueNew == nil {
+		return SongInfo{}
 	}
-	var currentSongData = songQue[currentSong]
+	var currentSongData = songQueNew[currentSong]
 
 	currentGameData := getCurrentGame(currentSongData)
 
-	return models.SongInfo{
+	return SongInfo{
 		Game:             currentGameData.GameName,
 		GamePlayed:       currentGameData.TimesPlayed,
 		Song:             currentSongData.SongName,
@@ -154,12 +205,12 @@ func GetSongInfo() models.SongInfo {
 	}
 }
 
-func GetPlayedSongs() []models.SongInfo {
-	var songList []models.SongInfo
+func GetPlayedSongs() []SongInfo {
+	var songList []SongInfo
 
-	for i, song := range songQue {
+	for i, song := range songQueNew {
 		gameData := getCurrentGame(song)
-		songList = append(songList, models.SongInfo{
+		songList = append(songList, SongInfo{
 			Game:             gameData.GameName,
 			GamePlayed:       gameData.TimesPlayed,
 			Song:             song.SongName,
@@ -173,34 +224,36 @@ func GetPlayedSongs() []models.SongInfo {
 
 func GetSong(song string) string {
 	currentSong, _ = strconv.Atoi(song)
-	if currentSong >= len(songQue) {
-		currentSong = len(songQue) - 1
+	if currentSong >= len(songQueNew) {
+		currentSong = len(songQueNew) - 1
 	} else if currentSong < 0 {
 		currentSong = 0
 	}
-	var songData = songQue[currentSong]
+	songData := songQueNew[currentSong]
 	return songData.Path
 }
 
 func GetAllGames() []string {
-	if games == nil || len(games) == 0 {
+	/*if games == nil || len(games) == 0 {
 		games = db.FindAllGames()
-	}
+	}*/
+	getAllGames()
 
 	var jsonArray []string
-	for _, game := range games {
+	for _, game := range gamesNew {
 		jsonArray = append(jsonArray, game.GameName)
 	}
 	return jsonArray
 }
 
 func GetAllGamesRandom() []string {
-	if games == nil || len(games) == 0 {
+	/*if games == nil || len(games) == 0 {
 		games = db.FindAllGames()
-	}
+	}*/
+	getAllGames()
 
 	var jsonArray []string
-	for _, game := range games {
+	for _, game := range gamesNew {
 		jsonArray = append(jsonArray, game.GameName)
 	}
 	rand.Shuffle(len(jsonArray), func(i, j int) { jsonArray[i], jsonArray[j] = jsonArray[j], jsonArray[i] })
@@ -208,40 +261,41 @@ func GetAllGamesRandom() []string {
 }
 
 func GetNextSong() string {
-	if songQue == nil {
+	if songQueNew == nil {
 		return ""
 	}
-	if currentSong == len(songQue)-1 || currentSong == -1 {
-		var songData = songQue[currentSong]
+	if currentSong == len(songQueNew)-1 || currentSong == -1 {
+		songData := songQueNew[currentSong]
 		return songData.Path
 	} else {
 		currentSong = currentSong + 1
-		var songData = songQue[currentSong]
+		songData := songQueNew[currentSong]
 		return songData.Path
 	}
 }
 
 func GetPreviousSong() string {
-	if songQue == nil {
+	if songQueNew == nil {
 		return ""
 	}
 	if currentSong == -1 || currentSong == 0 {
-		var songData = songQue[0]
+		songData := songQueNew[0]
 		return songData.Path
 	} else {
 		currentSong = currentSong - 1
-		var songData = songQue[currentSong]
+		songData := songQueNew[currentSong]
 		return songData.Path
 	}
 }
 
-func getSongFromList(games []models.GameData) models.SongData {
+func getSongFromList(games []repository.Game) repository.Song {
 	songFound := false
-	var song models.SongData
+	var song repository.Song
 	for !songFound {
 		game := getRandomGame(games)
 		//log.Println("game = ", game)
-		songs := db.FindSongsFromGame(game.Id)
+		//songs := db.FindSongsFromGame(game.Id)
+		songs, _ := repo.FindSongsFromGame(db.Ctx, game.ID)
 		//log.Println("songs = ", songs)
 		if len(songs) == 0 {
 			continue
@@ -254,10 +308,12 @@ func getSongFromList(games []models.GameData) models.SongData {
 		//log.Println("game.Path+song.FileName: ", game.Path+song.FileName)
 		//log.Println("song.Path: ", song.Path)
 		//log.Println("game.Path+song.FileName != song.Path: ", game.Path+song.FileName != song.Path)
-		if err != nil || game.Path+song.FileName != song.Path || strings.HasSuffix(song.FileName, ".wav") {
+		if err != nil || (song.FileName != nil && game.Path+*song.FileName != song.Path) || (song.FileName != nil && strings.HasSuffix(*song.FileName, ".wav")) {
 			//File not found
-			db.RemoveBrokenSong(song)
-			log.Println("Song not found, song '" + song.SongName + "' deleted from game '" + game.GameName + "' FileName: " + song.FileName)
+			//db.RemoveBrokenSong(song)
+			repo.RemoveBrokenSong(db.Ctx, song.Path)
+			//log.Println("Song not found, song '" + song.SongName + "' deleted from game '" + game.GameName + "' FileName: " + song.FileName)
+			log.Printf("Song not found, song '%s' deleted from game '%s' FileName: %v\n", song.SongName, game.GameName, song.FileName)
 		} else {
 			songFound = true
 		}
@@ -270,23 +326,24 @@ func getSongFromList(games []models.GameData) models.SongData {
 	return song
 }
 
-func getCurrentGame(currentSongData models.SongData) models.GameData {
-	for _, game := range games {
-		if game.Id == currentSongData.GameId {
+func getCurrentGame(currentSongData repository.Song) repository.Game {
+	for _, game := range gamesNew {
+		if game.ID == currentSongData.GameID {
 			return game
 		}
 	}
-	return models.GameData{}
+	return repository.Game{}
 }
 
-func getAveragePlayed(gameList []models.GameData) int {
-	var sum int
-	for _, data := range gameList {
+func getAveragePlayed() int32 {
+	getAllGames()
+	var sum int32
+	for _, data := range gamesNew {
 		sum += data.TimesPlayed
 	}
-	return sum / len(gameList)
+	return sum / int32(len(gamesNew))
 }
 
-func getRandomGame(listOfGames []models.GameData) models.GameData {
+func getRandomGame(listOfGames []repository.Game) repository.Game {
 	return listOfGames[rand.Intn(len(listOfGames))]
 }