#9 Changed the term game to soundtrack everywhere

internal/backend/sync.go

@@ -30,14 +30,14 @@ var start time.Time
 var totalTime time.Duration
 var timeSpent time.Duration
 
-var allGames []repository.Soundtrack
-var gamesBeforeSync []repository.Soundtrack
-var gamesAfterSync []repository.Soundtrack
-var gamesAdded []string
-var gamesReAdded []string
-var gamesChangedTitle map[string]string
-var gamesChangedContent []string
-var gamesRemoved []string
+var allSoundtracks []repository.Soundtrack
+var soundtracksBeforeSync []repository.Soundtrack
+var soundtracksAfterSync []repository.Soundtrack
+var soundtracksAdded []string
+var soundtracksReAdded []string
+var soundtracksChangedTitle map[string]string
+var soundtracksChangedContent []string
+var soundtracksRemoved []string
 var catchedErrors []string
 
 type brokenSong struct {
@@ -50,13 +50,13 @@ var pool *ants.Pool
 var poolSong *ants.Pool
 
 type SyncResponse struct {
-	GamesAdded          []string          `json:"games_added"`
-	GamesReAdded        []string          `json:"games_re_added"`
-	GamesChangedTitle   map[string]string `json:"games_changed_title"`
-	GamesChangedContent []string          `json:"games_changed_content"`
-	GamesRemoved        []string          `json:"games_removed"`
-	CatchedErrors       []string          `json:"catched_errors"`
-	TotalTime           string            `json:"total_time"`
+	SoundtracksAdded          []string          `json:"soundtracks_added"`
+	SoundtracksReAdded        []string          `json:"soundtracks_re_added"`
+	SoundtracksChangedTitle   map[string]string `json:"soundtracks_changed_title"`
+	SoundtracksChangedContent []string          `json:"soundtracks_changed_content"`
+	SoundtracksRemoved        []string          `json:"soundtracks_removed"`
+	CatchedErrors             []string          `json:"catched_errors"`
+	TotalTime                 string            `json:"total_time"`
 }
 
 type ProgressResponse struct {
@@ -64,24 +64,24 @@ type ProgressResponse struct {
 	TimeSpent string `json:"time_spent"`
 }
 
-type GameStatus int
+type SoundtrackStatus int
 
 const (
-	NotChanged GameStatus = iota
+	NotChanged SoundtrackStatus = iota
 	TitleChanged
-	GameChanged
-	NewGame
+	SoundtrackChanged
+	NewSoundtrack
 )
 
-var statusName = map[GameStatus]string{
-	NotChanged:   "Not changed",
-	TitleChanged: "Title changed",
-	GameChanged:  "Game changed",
-	NewGame:      "New game",
+var statusName = map[SoundtrackStatus]string{
+	NotChanged:        "Not changed",
+	TitleChanged:      "Title changed",
+	SoundtrackChanged: "Soundtrack changed",
+	NewSoundtrack:     "New soundtrack",
 }
 
-func (gs GameStatus) String() string {
-	return statusName[gs]
+func (ss SoundtrackStatus) String() string {
+	return statusName[ss]
 }
 
 func ResetDB() {
@@ -107,54 +107,54 @@ func SyncProgress() ProgressResponse {
 
 func SyncResult() SyncResponse {
 	logging.GetLogger().Info("Sync completed",
-		zap.Int("games_before", len(gamesBeforeSync)),
-		zap.Int("games_after", len(gamesAfterSync)))
+		zap.Int("soundtracks_before", len(soundtracksBeforeSync)),
+		zap.Int("soundtracks_after", len(soundtracksAfterSync)))
 
-	if len(gamesAdded) > 0 {
-		logging.GetLogger().Debug("Games added", zap.Strings("games", gamesAdded))
+	if len(soundtracksAdded) > 0 {
+		logging.GetLogger().Debug("Soundtracks added", zap.Strings("soundtracks", soundtracksAdded))
 	}
 
-	if len(gamesReAdded) > 0 {
-		logging.GetLogger().Debug("Games readded", zap.Strings("games", gamesReAdded))
+	if len(soundtracksReAdded) > 0 {
+		logging.GetLogger().Debug("Soundtracks readded", zap.Strings("soundtracks", soundtracksReAdded))
 	}
 
-	if len(gamesChangedTitle) > 0 {
-		logging.GetLogger().Debug("Games with changed title", zap.Any("changes", gamesChangedTitle))
+	if len(soundtracksChangedTitle) > 0 {
+		logging.GetLogger().Debug("Soundtracks with changed title", zap.Any("changes", soundtracksChangedTitle))
 	}
 
-	if len(gamesChangedContent) > 0 {
-		logging.GetLogger().Debug("Games with changed content", zap.Strings("games", gamesChangedContent))
+	if len(soundtracksChangedContent) > 0 {
+		logging.GetLogger().Debug("Soundtracks with changed content", zap.Strings("soundtracks", soundtracksChangedContent))
 	}
 
-	var gamesRemovedTemp []string
-	for _, beforeGame := range gamesBeforeSync {
+	var soundtracksRemovedTemp []string
+	for _, beforeSoundtrack := range soundtracksBeforeSync {
 		var found = false
-		for _, afterGame := range gamesAfterSync {
-			if beforeGame.SoundtrackName == afterGame.SoundtrackName {
+		for _, afterSoundtrack := range soundtracksAfterSync {
+			if beforeSoundtrack.SoundtrackName == afterSoundtrack.SoundtrackName {
 				found = true
 				break
 			}
 		}
 		if !found {
-			gamesRemovedTemp = append(gamesRemovedTemp, beforeGame.SoundtrackName)
+			soundtracksRemovedTemp = append(soundtracksRemovedTemp, beforeSoundtrack.SoundtrackName)
 		}
 	}
 
-	for _, game := range gamesRemovedTemp {
+	for _, soundtrack := range soundtracksRemovedTemp {
 		var found bool = false
-		for key := range gamesChangedTitle {
-			if game == key {
+		for key := range soundtracksChangedTitle {
+			if soundtrack == key {
 				found = true
 				break
 			}
 		}
 		if !found {
-			gamesRemoved = append(gamesRemoved, game)
+			soundtracksRemoved = append(soundtracksRemoved, soundtrack)
 		}
 	}
 
-	if len(gamesRemoved) > 0 {
-		logging.GetLogger().Debug("Games removed", zap.Strings("games", gamesRemoved))
+	if len(soundtracksRemoved) > 0 {
+		logging.GetLogger().Debug("Soundtracks removed", zap.Strings("soundtracks", soundtracksRemoved))
 	}
 
 	if len(catchedErrors) > 0 {
@@ -165,27 +165,27 @@ func SyncResult() SyncResponse {
 	logging.GetLogger().Info("Sync completed", zap.String("total_time", out.Format("15:04:05.00000")))
 
 	return SyncResponse{
-		GamesAdded:          gamesAdded,
-		GamesReAdded:        gamesReAdded,
-		GamesChangedTitle:   gamesChangedTitle,
-		GamesChangedContent: gamesChangedContent,
-		GamesRemoved:        gamesRemoved,
-		CatchedErrors:       catchedErrors,
-		TotalTime:           out.Format("15:04:05"),
+		SoundtracksAdded:          soundtracksAdded,
+		SoundtracksReAdded:        soundtracksReAdded,
+		SoundtracksChangedTitle:   soundtracksChangedTitle,
+		SoundtracksChangedContent: soundtracksChangedContent,
+		SoundtracksRemoved:        soundtracksRemoved,
+		CatchedErrors:             catchedErrors,
+		TotalTime:                 out.Format("15:04:05"),
 	}
 }
 
 func SyncSoundtracksNewFull() {
-	syncGamesNew(true)
+	syncSoundtracksNew(true)
 	Reset()
 }
 
 func SyncSoundtracksNewOnlyChanges() {
-	syncGamesNew(false)
+	syncSoundtracksNew(false)
 	Reset()
 }
 
-func syncGamesNew(full bool) {
+func syncSoundtracksNew(full bool) {
 	musicPath := os.Getenv("MUSIC_PATH")
 	fmt.Printf("dir: %s\n", musicPath)
 	logging.GetLogger().Debug("Folder to sync", zap.String("MUSIC_PATH", musicPath))
@@ -201,19 +201,19 @@ func syncGamesNew(full bool) {
 	logging.GetLogger().Debug("Folders to skip during sync", zap.Strings("folders", foldersToSkip))
 
 	var err error
-	gamesAdded = nil
-	gamesReAdded = nil
-	gamesChangedTitle = nil
-	gamesChangedContent = nil
-	gamesRemoved = nil
+	soundtracksAdded = nil
+	soundtracksReAdded = nil
+	soundtracksChangedTitle = nil
+	soundtracksChangedContent = nil
+	soundtracksRemoved = nil
 	catchedErrors = nil
 	brokenSongs = nil
 
-	gamesBeforeSync, err = repo.FindAllSoundtracks(BackendCtx())
+	soundtracksBeforeSync, err = repo.FindAllSoundtracks(BackendCtx())
 	handleError("FindAllSoundtracks Before", err, "")
-	logging.GetLogger().Info("Starting sync", zap.Int("games_before", len(gamesBeforeSync)))
+	logging.GetLogger().Info("Starting sync", zap.Int("soundtracks_before", len(soundtracksBeforeSync)))
 
-	allGames, err = repo.GetAllSoundtracksIncludingDeleted(BackendCtx())
+	allSoundtracks, err = repo.GetAllSoundtracksIncludingDeleted(BackendCtx())
 	handleError("GetAllSoundtracksIncludingDeleted", err, "")
 	err = repo.SetSoundtrackDeletionDate(BackendCtx())
 	handleError("SetSoundtrackDeletionDate", err, "")
@@ -233,13 +233,13 @@ func syncGamesNew(full bool) {
 	for _, dir := range directories {
 		pool.Submit(func() {
 			defer syncWg.Done()
-			syncGameNew(dir, foldersToSkip, musicPath, full)
+			syncSoundtrackNew(dir, foldersToSkip, musicPath, full)
 		})
 	}
 	syncWg.Wait()
 	checkBrokenSongsNew()
 
-	gamesAfterSync, err = repo.FindAllSoundtracks(BackendCtx())
+	soundtracksAfterSync, err = repo.FindAllSoundtracks(BackendCtx())
 	handleError("FindAllSoundtracks After", err, "")
 
 	finished := time.Now()
@@ -286,48 +286,48 @@ func checkBrokenSongNew(song repository.Song) {
 	}
 }
 
-func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full bool) {
+func syncSoundtrackNew(file os.DirEntry, foldersToSkip []string, baseDir string, full bool) {
 	if file.IsDir() && !contains(foldersToSkip, file.Name()) {
-		logging.GetLogger().Debug("Syncing game", zap.String("game", file.Name()))
-		gameDir := baseDir + file.Name() + "/"
-		dirHash := getHashForDir(gameDir)
+		logging.GetLogger().Debug("Syncing soundtrack", zap.String("soundtrack", file.Name()))
+		soundtrackDir := baseDir + file.Name() + "/"
+		dirHash := getHashForDir(soundtrackDir)
 
-		var status GameStatus = NewGame
-		var oldGame repository.Soundtrack
+		var status SoundtrackStatus = NewSoundtrack
+		var oldSoundtrack repository.Soundtrack
 		var id int32 = -1
 
-		//fmt.Printf("Games before: %d\n", len(gamesBeforeSync))
+		//fmt.Printf("Soundtracks before: %d\n", len(soundtracksBeforeSync))
 
-		for _, currentGame := range allGames {
-			oldGame = currentGame
-			//fmt.Printf("%s | %s\n", oldGame.SoundtrackName, oldGame.Hash)
-			if oldGame.SoundtrackName == file.Name() && oldGame.Hash == dirHash {
+		for _, currentSoundtrack := range allSoundtracks {
+			oldSoundtrack = currentSoundtrack
+			//fmt.Printf("%s | %s\n", oldSoundtrack.SoundtrackName, oldSoundtrack.Hash)
+			if oldSoundtrack.SoundtrackName == file.Name() && oldSoundtrack.Hash == dirHash {
 				status = NotChanged
-				id = oldGame.ID
-				//fmt.Printf("Game not changed\n")
+				id = oldSoundtrack.ID
+				//fmt.Printf("Soundtrack not changed\n")
 				break
-			} else if oldGame.SoundtrackName == file.Name() && oldGame.Hash != dirHash {
-				status = GameChanged
-				id = oldGame.ID
-				//fmt.Printf("Game changed\n")
+			} else if oldSoundtrack.SoundtrackName == file.Name() && oldSoundtrack.Hash != dirHash {
+				status = SoundtrackChanged
+				id = oldSoundtrack.ID
+				//fmt.Printf("Soundtrack changed\n")
 				break
-			} else if oldGame.SoundtrackName != file.Name() && oldGame.Hash == dirHash {
+			} else if oldSoundtrack.SoundtrackName != file.Name() && oldSoundtrack.Hash == dirHash {
 				status = TitleChanged
-				id = oldGame.ID
+				id = oldSoundtrack.ID
 				//fmt.Printf("SoundtrackName changed\n")
 				break
 			}
 		}
 
-		if full && status != NewGame {
+		if full && status != NewSoundtrack {
 			status = TitleChanged
 		}
-		entries, err := os.ReadDir(gameDir)
+		entries, err := os.ReadDir(soundtrackDir)
 		if err != nil {
-			logging.GetLogger().Error("Failed to read game directory", zap.String("path", gameDir), zap.String("error", err.Error()))
+			logging.GetLogger().Error("Failed to read soundtrack directory", zap.String("path", soundtrackDir), zap.String("error", err.Error()))
 		}
 		switch status {
-		case NewGame:
+		case NewSoundtrack:
 			if id != -1 {
 				for _, entry := range entries {
 					fileInfo, err := entry.Info()
@@ -340,13 +340,13 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 						break
 					}
 				}
-				err = repo.InsertSoundtrackWithExistingId(BackendCtx(), repository.InsertSoundtrackWithExistingIdParams{ID: id, SoundtrackName: file.Name(), Path: gameDir, Hash: dirHash})
+				err = repo.InsertSoundtrackWithExistingId(BackendCtx(), repository.InsertSoundtrackWithExistingIdParams{ID: id, SoundtrackName: file.Name(), Path: soundtrackDir, Hash: dirHash})
 				handleError("InsertSoundtrackWithExistingId", err, "")
 				if err != nil {
-					logging.GetLogger().Debug("Game already exists, removing old ID file",
+					logging.GetLogger().Debug("Soundtrack already exists, removing old ID file",
 						zap.Int32("id", id),
-						zap.String("game_dir", gameDir))
-					fileName := gameDir + "/." + strconv.Itoa(int(id)) + ".id"
+						zap.String("soundtrack_dir", soundtrackDir))
+					fileName := soundtrackDir + "/." + strconv.Itoa(int(id)) + ".id"
 					logging.GetLogger().Debug("Removing ID file", zap.String("filename", fileName))
 
 					err := os.Remove(fileName)
@@ -354,50 +354,50 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 						logging.GetLogger().Error("Failed to remove ID file", zap.String("filename", fileName), zap.String("error", err.Error()))
 					}
 
-					newDirHash := getHashForDir(gameDir)
+					newDirHash := getHashForDir(soundtrackDir)
 
-					id = insertGameNew(file.Name(), gameDir, newDirHash)
+					id = insertSoundtrackNew(file.Name(), soundtrackDir, newDirHash)
 				}
 			} else {
-				id = insertGameNew(file.Name(), gameDir, dirHash)
+				id = insertSoundtrackNew(file.Name(), soundtrackDir, dirHash)
 			}
-			logging.GetLogger().Debug("New game detected",
+			logging.GetLogger().Debug("New soundtrack detected",
 				zap.Int32("id", id),
-				zap.String("game", file.Name()),
+				zap.String("soundtrack", file.Name()),
 				zap.String("hash", dirHash),
 				zap.String("status", status.String()))
-			gamesAdded = append(gamesAdded, file.Name())
-			newCheckSongs(entries, gameDir, id)
-		case GameChanged:
-			logging.GetLogger().Debug("Game changed",
+			soundtracksAdded = append(soundtracksAdded, file.Name())
+			newCheckSongs(entries, soundtrackDir, id)
+		case SoundtrackChanged:
+			logging.GetLogger().Debug("Soundtrack changed",
 				zap.Int32("id", id),
-				zap.String("game", file.Name()),
+				zap.String("soundtrack", file.Name()),
 				zap.String("hash", dirHash),
 				zap.String("status", status.String()))
 			err = repo.UpdateSoundtrackHash(BackendCtx(), repository.UpdateSoundtrackHashParams{Hash: dirHash, ID: id})
 			handleError("UpdateSoundtrackHash", err, "")
-			gamesChangedContent = append(gamesChangedContent, file.Name())
-			newCheckSongs(entries, gameDir, id)
+			soundtracksChangedContent = append(soundtracksChangedContent, file.Name())
+			newCheckSongs(entries, soundtrackDir, id)
 		case TitleChanged:
-			logging.GetLogger().Debug("Game title changed",
+			logging.GetLogger().Debug("Soundtrack title changed",
 				zap.Int32("id", id),
-				zap.String("oldName", oldGame.SoundtrackName),
+				zap.String("oldName", oldSoundtrack.SoundtrackName),
 				zap.String("newName", file.Name()),
 				zap.String("hash", dirHash),
 				zap.String("status", status.String()))
-			err = repo.UpdateSoundtrackName(BackendCtx(), repository.UpdateSoundtrackNameParams{Name: file.Name(), Path: gameDir, ID: id})
+			err = repo.UpdateSoundtrackName(BackendCtx(), repository.UpdateSoundtrackNameParams{Name: file.Name(), Path: soundtrackDir, ID: id})
 			handleError("UpdateSoundtrackName", err, "")
-			newCheckSongs(entries, gameDir, id)
-			if gamesChangedTitle == nil {
-				gamesChangedTitle = make(map[string]string)
+			newCheckSongs(entries, soundtrackDir, id)
+			if soundtracksChangedTitle == nil {
+				soundtracksChangedTitle = make(map[string]string)
 			}
-			gamesChangedTitle[oldGame.SoundtrackName] = file.Name()
+			soundtracksChangedTitle[oldSoundtrack.SoundtrackName] = file.Name()
 		case NotChanged:
 			var found bool = false
-			for _, beforeGame := range gamesBeforeSync {
-				if dirHash == beforeGame.Hash {
+			for _, beforeSoundtrack := range soundtracksBeforeSync {
+				if dirHash == beforeSoundtrack.Hash {
 					found = true
-					logging.GetLogger().Debug("Game not changed",
+					logging.GetLogger().Debug("Soundtrack not changed",
 						zap.Int32("id", id),
 						zap.String("newName", file.Name()),
 						zap.String("hash", dirHash),
@@ -405,9 +405,9 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 				}
 			}
 			if !found {
-				newCheckSongs(entries, gameDir, id)
-				gamesReAdded = append(gamesReAdded, file.Name())
-				logging.GetLogger().Debug("Game added again",
+				newCheckSongs(entries, soundtrackDir, id)
+				soundtracksReAdded = append(soundtracksReAdded, file.Name())
+				logging.GetLogger().Debug("Soundtrack added again",
 					zap.Int32("id", id),
 					zap.String("newName", file.Name()),
 					zap.String("hash", dirHash),
@@ -415,9 +415,9 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 
 			}
 		}
-		logging.GetLogger().Debug("Game sync status",
+		logging.GetLogger().Debug("Soundtrack sync status",
 			zap.Int32("id", id),
-			zap.String("game", file.Name()),
+			zap.String("soundtrack", file.Name()),
 			zap.String("hash", dirHash),
 			zap.String("status", status.String()))
 		err = repo.RemoveSoundtrackDeletionDate(BackendCtx(), id)
@@ -430,24 +430,24 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
 		zap.Int("percent", int((foldersSynced/numberOfFoldersToSync)*100)))
 }
 
-func insertGameNew(name string, path string, hash string) int32 {
+func insertSoundtrackNew(name string, path string, hash string) int32 {
 	var duplicateError = errors.New("ERROR: duplicate key value violates unique")
 	id, err := repo.InsertSoundtrack(BackendCtx(), repository.InsertSoundtrackParams{SoundtrackName: name, Path: path, Hash: hash})
 	handleError("InsertSoundtrack", err, "")
 	if err != nil {
 		logging.GetLogger().Warn("ID collision detected, resetting sequence")
 		if strings.HasPrefix(err.Error(), duplicateError.Error()) {
-			logging.GetLogger().Debug("Resetting game ID sequence")
+			logging.GetLogger().Debug("Resetting soundtrack ID sequence")
 			_, err = repo.ResetSoundtrackIdSeq(BackendCtx())
 			handleError("ResetSoundtrackIdSeq", err, "")
-			id = insertGameNew(name, path, hash)
+			id = insertSoundtrackNew(name, path, hash)
 		}
 	}
 	return id
 
 }
 
-func newCheckSongs(entries []os.DirEntry, gameDir string, id int32) int32 {
+func newCheckSongs(entries []os.DirEntry, soundtrackDir string, id int32) int32 {
 	//hasher := md5.New()
 	var numberOfSongs int32
 	numberOfFiles := len(entries)
@@ -457,7 +457,7 @@ func newCheckSongs(entries []os.DirEntry, gameDir string, id int32) int32 {
 	for _, entry := range entries {
 		poolSong.Submit(func() {
 			defer songWg.Done()
-			if newCheckSong(entry, gameDir, id) {
+			if newCheckSong(entry, soundtrackDir, id) {
 				numberOfSongs++
 			}
 		})
@@ -466,7 +466,7 @@ func newCheckSongs(entries []os.DirEntry, gameDir string, id int32) int32 {
 	return numberOfSongs
 }
 
-func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
+func newCheckSong(entry os.DirEntry, soundtrackDir string, id int32) bool {
 	fileInfo, err := entry.Info()
 	if err != nil {
 		logging.GetLogger().Error("Failed to get file info", zap.String("filename", entry.Name()), zap.String("error", err.Error()))
@@ -474,7 +474,7 @@ func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
 	}
 
 	if isSong(fileInfo) {
-		path := gameDir + entry.Name()
+		path := soundtrackDir + entry.Name()
 
 		songHash := getHashForFile(path)
 		//numberOfSongs++
@@ -490,7 +490,7 @@ func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
 			}
 		}
 		logging.GetLogger().Debug("Song changed",
-			zap.Int32("game_id", id),
+			zap.Int32("soundtrack_id", id),
 			zap.String("path", path),
 			zap.String("song_name", songName),
 			zap.String("song_hash", songHash))
@@ -548,8 +548,8 @@ func handleError(funcName string, err error, msg string) {
 	}
 }
 
-func getHashForDir(gameDir string) string {
-	directory, _ := directory_checksum.ScanDirectory(gameDir, afero.NewOsFs())
+func getHashForDir(soundtrackDir string) string {
+	directory, _ := directory_checksum.ScanDirectory(soundtrackDir, afero.NewOsFs())
 	hash, _ := directory.ComputeDirectoryChecksums()
 
 	return hash