Added fuzzy finder to search, made sync check as middleware, .id file is never used

internal/backend/sync.go

@@ -175,17 +175,17 @@ func SyncResult() SyncResponse {
 	}
 }
 
-func SyncSoundtracksNewFull() {
-	syncSoundtracksNew(true)
+func SyncSoundtracksFull() {
+	syncSoundtracks(true)
 	Reset()
 }
 
-func SyncSoundtracksNewOnlyChanges() {
-	syncSoundtracksNew(false)
+func SyncSoundtracksOnlyChanges() {
+	syncSoundtracks(false)
 	Reset()
 }
 
-func syncSoundtracksNew(full bool) {
+func syncSoundtracks(full bool) {
 	musicPath := os.Getenv("MUSIC_PATH")
 	fmt.Printf("dir: %s\n", musicPath)
 	logging.GetLogger().Debug("Folder to sync", zap.String("MUSIC_PATH", musicPath))
@@ -233,11 +233,11 @@ func syncSoundtracksNew(full bool) {
 	for _, dir := range directories {
 		pool.Submit(func() {
 			defer syncWg.Done()
-			syncSoundtrackNew(dir, foldersToSkip, musicPath, full)
+			syncSoundtrack(dir, foldersToSkip, musicPath, full)
 		})
 	}
 	syncWg.Wait()
-	checkBrokenSongsNew()
+	checkBrokenSongs()
 
 	soundtracksAfterSync, err = repo.FindAllSoundtracks(BackendCtx())
 	handleError("FindAllSoundtracks After", err, "")
@@ -250,7 +250,7 @@ func syncSoundtracksNew(full bool) {
 	Syncing = false
 }
 
-func checkBrokenSongsNew() {
+func checkBrokenSongs() {
 	allSongs, err := repo.FetchAllSongs(BackendCtx())
 	handleError("FetchAllSongs", err, "")
 	var brokenWg sync.WaitGroup
@@ -261,7 +261,7 @@ func checkBrokenSongsNew() {
 	for _, song := range allSongs {
 		poolBroken.Submit(func() {
 			defer brokenWg.Done()
-			checkBrokenSongNew(song)
+			checkBrokenSong(song)
 		})
 	}
 	brokenWg.Wait()
@@ -271,7 +271,7 @@ func checkBrokenSongsNew() {
 	}
 }
 
-func checkBrokenSongNew(song repository.Song) {
+func checkBrokenSong(song repository.Song) {
 	//Check if file exists and open
 	openFile, err := os.Open(song.Path)
 	if err != nil {
@@ -286,7 +286,7 @@ func checkBrokenSongNew(song repository.Song) {
 	}
 }
 
-func syncSoundtrackNew(file os.DirEntry, foldersToSkip []string, baseDir string, full bool) {
+func syncSoundtrack(file os.DirEntry, foldersToSkip []string, baseDir string, full bool) {
 	if file.IsDir() && !contains(foldersToSkip, file.Name()) {
 		logging.GetLogger().Debug("Syncing soundtrack", zap.String("soundtrack", file.Name()))
 		soundtrackDir := baseDir + file.Name() + "/"
@@ -328,46 +328,14 @@ func syncSoundtrackNew(file os.DirEntry, foldersToSkip []string, baseDir string,
 		}
 		switch status {
 		case NewSoundtrack:
-			if id != -1 {
-				for _, entry := range entries {
-					fileInfo, err := entry.Info()
-					if err != nil {
-						logging.GetLogger().Error("Failed to get file info", zap.String("error", err.Error()))
-						continue
-					}
-					id = getIdFromFileNew(fileInfo)
-					if id != -1 {
-						break
-					}
-				}
-				err = repo.InsertSoundtrackWithExistingId(BackendCtx(), repository.InsertSoundtrackWithExistingIdParams{ID: id, SoundtrackName: file.Name(), Path: soundtrackDir, Hash: dirHash})
-				handleError("InsertSoundtrackWithExistingId", err, "")
-				if err != nil {
-					logging.GetLogger().Debug("Soundtrack already exists, removing old ID file",
-						zap.Int32("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)
-					if err != nil {
-						logging.GetLogger().Error("Failed to remove ID file", zap.String("filename", fileName), zap.String("error", err.Error()))
-					}
-
-					newDirHash := getHashForDir(soundtrackDir)
-
-					id = insertSoundtrackNew(file.Name(), soundtrackDir, newDirHash)
-				}
-			} else {
-				id = insertSoundtrackNew(file.Name(), soundtrackDir, dirHash)
-			}
+			id = insertSoundtrack(file.Name(), soundtrackDir, dirHash)
 			logging.GetLogger().Debug("New soundtrack detected",
 				zap.Int32("id", id),
 				zap.String("soundtrack", file.Name()),
 				zap.String("hash", dirHash),
 				zap.String("status", status.String()))
 			soundtracksAdded = append(soundtracksAdded, file.Name())
-			newCheckSongs(entries, soundtrackDir, id)
+			checkSongs(entries, soundtrackDir, id)
 		case SoundtrackChanged:
 			logging.GetLogger().Debug("Soundtrack changed",
 				zap.Int32("id", id),
@@ -377,7 +345,7 @@ func syncSoundtrackNew(file os.DirEntry, foldersToSkip []string, baseDir string,
 			err = repo.UpdateSoundtrackHash(BackendCtx(), repository.UpdateSoundtrackHashParams{Hash: dirHash, ID: id})
 			handleError("UpdateSoundtrackHash", err, "")
 			soundtracksChangedContent = append(soundtracksChangedContent, file.Name())
-			newCheckSongs(entries, soundtrackDir, id)
+			checkSongs(entries, soundtrackDir, id)
 		case TitleChanged:
 			logging.GetLogger().Debug("Soundtrack title changed",
 				zap.Int32("id", id),
@@ -387,7 +355,7 @@ func syncSoundtrackNew(file os.DirEntry, foldersToSkip []string, baseDir string,
 				zap.String("status", status.String()))
 			err = repo.UpdateSoundtrackName(BackendCtx(), repository.UpdateSoundtrackNameParams{Name: file.Name(), Path: soundtrackDir, ID: id})
 			handleError("UpdateSoundtrackName", err, "")
-			newCheckSongs(entries, soundtrackDir, id)
+			checkSongs(entries, soundtrackDir, id)
 			if soundtracksChangedTitle == nil {
 				soundtracksChangedTitle = make(map[string]string)
 			}
@@ -405,7 +373,7 @@ func syncSoundtrackNew(file os.DirEntry, foldersToSkip []string, baseDir string,
 				}
 			}
 			if !found {
-				newCheckSongs(entries, soundtrackDir, id)
+				checkSongs(entries, soundtrackDir, id)
 				soundtracksReAdded = append(soundtracksReAdded, file.Name())
 				logging.GetLogger().Debug("Soundtrack added again",
 					zap.Int32("id", id),
@@ -430,7 +398,7 @@ func syncSoundtrackNew(file os.DirEntry, foldersToSkip []string, baseDir string,
 		zap.Int("percent", int((foldersSynced/numberOfFoldersToSync)*100)))
 }
 
-func insertSoundtrackNew(name string, path string, hash string) int32 {
+func insertSoundtrack(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, "")
@@ -440,14 +408,14 @@ func insertSoundtrackNew(name string, path string, hash string) int32 {
 			logging.GetLogger().Debug("Resetting soundtrack ID sequence")
 			_, err = repo.ResetSoundtrackIdSeq(BackendCtx())
 			handleError("ResetSoundtrackIdSeq", err, "")
-			id = insertSoundtrackNew(name, path, hash)
+			id = insertSoundtrack(name, path, hash)
 		}
 	}
 	return id
 
 }
 
-func newCheckSongs(entries []os.DirEntry, soundtrackDir string, id int32) int32 {
+func checkSongs(entries []os.DirEntry, soundtrackDir string, id int32) int32 {
 	//hasher := md5.New()
 	var numberOfSongs int32
 	numberOfFiles := len(entries)
@@ -457,7 +425,7 @@ func newCheckSongs(entries []os.DirEntry, soundtrackDir string, id int32) int32
 	for _, entry := range entries {
 		poolSong.Submit(func() {
 			defer songWg.Done()
-			if newCheckSong(entry, soundtrackDir, id) {
+			if checkSong(entry, soundtrackDir, id) {
 				numberOfSongs++
 			}
 		})
@@ -466,7 +434,7 @@ func newCheckSongs(entries []os.DirEntry, soundtrackDir string, id int32) int32
 	return numberOfSongs
 }
 
-func newCheckSong(entry os.DirEntry, soundtrackDir string, id int32) bool {
+func checkSong(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()))
@@ -570,7 +538,7 @@ func getHashForFile(path string) string {
 	return hex.EncodeToString(hasher.Sum(nil))
 }
 
-func getIdFromFileNew(file os.FileInfo) int32 {
+func getIdFromFile(file os.FileInfo) int32 {
 	name := file.Name()
 	if !file.IsDir() && strings.HasSuffix(name, ".id") {
 		name = strings.Replace(name, ".id", "", 1)

internal/backend/sync_test.go

@@ -9,10 +9,10 @@ import (
 
 func TestContains(t *testing.T) {
 	tests := []struct {
-		name      string
-		slice     []string
-		search    string
-		expected  bool
+		name     string
+		slice    []string
+		search   string
+		expected bool
 	}{
 		{
 			name:     "element exists",
@@ -155,9 +155,9 @@ func TestGetIdFromFileNew(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := getIdFromFileNew(tt.fileInfo)
+			result := getIdFromFile(tt.fileInfo)
 			if result != tt.expected {
-				t.Errorf("getIdFromFileNew() = %v, want %v", result, tt.expected)
+				t.Errorf("getIdFromFile() = %v, want %v", result, tt.expected)
 			}
 		})
 	}
@@ -172,10 +172,10 @@ type mockFileInfoForSong struct {
 
 func (m *mockFileInfoForSong) Name() string       { return m.name }
 func (m *mockFileInfoForSong) Size() int64        { return m.size }
-func (m *mockFileInfoForSong) Mode() os.FileMode   { return 0 }
-func (m *mockFileInfoForSong) ModTime() time.Time  { return time.Time{} }
-func (m *mockFileInfoForSong) IsDir() bool         { return m.isDir }
-func (m *mockFileInfoForSong) Sys() interface{}    { return nil }
+func (m *mockFileInfoForSong) Mode() os.FileMode  { return 0 }
+func (m *mockFileInfoForSong) ModTime() time.Time { return time.Time{} }
+func (m *mockFileInfoForSong) IsDir() bool        { return m.isDir }
+func (m *mockFileInfoForSong) Sys() interface{}   { return nil }
 
 type mockFileInfoForCover struct {
 	name  string
@@ -185,10 +185,10 @@ type mockFileInfoForCover struct {
 
 func (m *mockFileInfoForCover) Name() string       { return m.name }
 func (m *mockFileInfoForCover) Size() int64        { return m.size }
-func (m *mockFileInfoForCover) Mode() os.FileMode   { return 0 }
-func (m *mockFileInfoForCover) ModTime() time.Time  { return time.Time{} }
-func (m *mockFileInfoForCover) IsDir() bool         { return m.isDir }
-func (m *mockFileInfoForCover) Sys() interface{}    { return nil }
+func (m *mockFileInfoForCover) Mode() os.FileMode  { return 0 }
+func (m *mockFileInfoForCover) ModTime() time.Time { return time.Time{} }
+func (m *mockFileInfoForCover) IsDir() bool        { return m.isDir }
+func (m *mockFileInfoForCover) Sys() interface{}   { return nil }
 
 type mockFileInfoForId struct {
 	name  string
@@ -198,7 +198,7 @@ type mockFileInfoForId struct {
 
 func (m *mockFileInfoForId) Name() string       { return m.name }
 func (m *mockFileInfoForId) Size() int64        { return m.size }
-func (m *mockFileInfoForId) Mode() os.FileMode   { return 0 }
-func (m *mockFileInfoForId) ModTime() time.Time  { return time.Time{} }
-func (m *mockFileInfoForId) IsDir() bool         { return m.isDir }
-func (m *mockFileInfoForId) Sys() interface{}    { return nil }
+func (m *mockFileInfoForId) Mode() os.FileMode  { return 0 }
+func (m *mockFileInfoForId) ModTime() time.Time { return time.Time{} }
+func (m *mockFileInfoForId) IsDir() bool        { return m.isDir }
+func (m *mockFileInfoForId) Sys() interface{}   { return nil }

internal/server/middleware/sync_check.go

@@ -0,0 +1,22 @@
+package middleware
+
+import (
+	"music-server/internal/backend"
+	"music-server/internal/logging"
+	"net/http"
+
+	"github.com/labstack/echo/v5"
+)
+
+// SyncCheckMiddleware blocks requests when syncing is in progress.
+// It returns HTTP 423 Locked with a standard message.
+// This middleware should be applied to handlers that cannot execute during sync.
+func SyncCheckMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
+	return func(c *echo.Context) error {
+		if backend.Syncing {
+			logging.GetLogger().Info("Syncing is in progress - request blocked")
+			return c.JSON(http.StatusLocked, "Syncing is in progress")
+		}
+		return next(c)
+	}
+}

internal/server/musicHandler.go

@@ -31,10 +31,6 @@ func NewMusicHandler() *MusicHandler {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music [get]
 func (m *MusicHandler) GetSong(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	song := ctx.QueryParam("song")
 	if song == "" {
 		return ctx.String(http.StatusBadRequest, "song can't be empty")
@@ -58,10 +54,6 @@ func (m *MusicHandler) GetSong(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/soundTest [get]
 func (m *MusicHandler) GetSoundCheckSong(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetSoundCheckSong()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -80,10 +72,6 @@ func (m *MusicHandler) GetSoundCheckSong(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/reset [get]
 func (m *MusicHandler) ResetMusic(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	backend.Reset()
 	return ctx.NoContent(http.StatusOK)
 }
@@ -98,10 +86,6 @@ func (m *MusicHandler) ResetMusic(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/rand [get]
 func (m *MusicHandler) GetRandomSong(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetRandomSong()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -121,10 +105,6 @@ func (m *MusicHandler) GetRandomSong(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/rand/low [get]
 func (m *MusicHandler) GetRandomSongLowChance(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetRandomSongLowChance()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -144,10 +124,6 @@ func (m *MusicHandler) GetRandomSongLowChance(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/rand/classic [get]
 func (m *MusicHandler) GetRandomSongClassic(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetRandomSongClassic()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -193,10 +169,6 @@ func (m *MusicHandler) GetPlayedSongs(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/next [get]
 func (m *MusicHandler) GetNextSong(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetNextSong()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -216,10 +188,6 @@ func (m *MusicHandler) GetNextSong(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/previous [get]
 func (m *MusicHandler) GetPreviousSong(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	songPath := backend.GetPreviousSong()
 	file, err := os.Open(songPath)
 	if err != nil {
@@ -239,10 +207,6 @@ func (m *MusicHandler) GetPreviousSong(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/all/order [get]
 func (m *MusicHandler) GetAllSoundtracks(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	soundtrackList := backend.GetAllSoundtracks()
 	return ctx.JSON(http.StatusOK, soundtrackList)
 }
@@ -257,10 +221,6 @@ func (m *MusicHandler) GetAllSoundtracks(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/all/random [get]
 func (m *MusicHandler) GetAllSoundtracksRandom(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	soundtrackList := backend.GetAllSoundtracksRandom()
 	return ctx.JSON(http.StatusOK, soundtrackList)
 }
@@ -277,10 +237,6 @@ func (m *MusicHandler) GetAllSoundtracksRandom(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/played [put]
 func (m *MusicHandler) PutPlayed(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	song, err := strconv.Atoi(ctx.QueryParam("song"))
 	if err != nil {
 		return ctx.JSON(http.StatusBadRequest, err.Error())
@@ -299,10 +255,6 @@ func (m *MusicHandler) PutPlayed(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/addQue [get]
 func (m *MusicHandler) AddLatestToQue(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	backend.AddLatestToQue()
 	return ctx.NoContent(http.StatusOK)
 }
@@ -316,10 +268,6 @@ func (m *MusicHandler) AddLatestToQue(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /music/addPlayed [get]
 func (m *MusicHandler) AddLatestPlayed(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Info("Syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	backend.AddLatestPlayed()
 	return ctx.NoContent(http.StatusOK)
 }

internal/server/routes.go

@@ -50,8 +50,9 @@ func (s *Server) RegisterRoutes() http.Handler {
 	fileServer := http.FileServer(http.FS(web.Assets))
 	e.GET("/assets/*", echo.WrapHandler(fileServer))
 
-	e.GET("/search", echo.WrapHandler(templ.Handler(web.HelloForm())))
+	e.GET("/search", echo.WrapHandler(templ.Handler(web.SearchForm())))
 	e.POST("/find", echo.WrapHandler(http.HandlerFunc(web.FindSoundtrackWebHandler)))
+	e.POST("/findfuzzy", echo.WrapHandler(http.HandlerFunc(web.FindSoundtrackFuzzyWebHandler)))
 
 	e.Static("/", "/frontend")
 
@@ -82,32 +83,32 @@ func (s *Server) RegisterRoutes() http.Handler {
 
 	sync := NewSyncHandler()
 	syncGroup := e.Group("/sync")
-	syncGroup.GET("", deprecatedMiddleware(sync.SyncSoundtracksNewOnlyChanges))
+	syncGroup.GET("", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewOnlyChanges)))
 	syncGroup.GET("/progress", deprecatedMiddleware(sync.SyncProgress))
-	syncGroup.GET("/new", deprecatedMiddleware(sync.SyncSoundtracksNewOnlyChanges))
-	syncGroup.GET("/full", deprecatedMiddleware(sync.SyncSoundtracksNewFull))
-	syncGroup.GET("/new/full", deprecatedMiddleware(sync.SyncSoundtracksNewFull))
-	syncGroup.GET("/quick", deprecatedMiddleware(sync.SyncSoundtracksNewOnlyChanges))
-	syncGroup.GET("/reset", deprecatedMiddleware(sync.ResetDB))
+	syncGroup.GET("/new", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewOnlyChanges)))
+	syncGroup.GET("/full", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewFull)))
+	syncGroup.GET("/new/full", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewFull)))
+	syncGroup.GET("/quick", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewOnlyChanges)))
+	syncGroup.GET("/reset", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.ResetDB)))
 
 	music := NewMusicHandler()
 	musicGroup := e.Group("/music")
-	musicGroup.GET("", deprecatedMiddleware(music.GetSong))
-	musicGroup.GET("/soundTest", deprecatedMiddleware(music.GetSoundCheckSong))
-	musicGroup.GET("/reset", deprecatedMiddleware(music.ResetMusic))
-	musicGroup.GET("/rand", deprecatedMiddleware(music.GetRandomSong))
-	musicGroup.GET("/rand/low", deprecatedMiddleware(music.GetRandomSongLowChance))
-	musicGroup.GET("/rand/classic", deprecatedMiddleware(music.GetRandomSongClassic))
+	musicGroup.GET("", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetSong)))
+	musicGroup.GET("/soundTest", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetSoundCheckSong)))
+	musicGroup.GET("/reset", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.ResetMusic)))
+	musicGroup.GET("/rand", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetRandomSong)))
+	musicGroup.GET("/rand/low", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetRandomSongLowChance)))
+	musicGroup.GET("/rand/classic", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetRandomSongClassic)))
 	musicGroup.GET("/info", deprecatedMiddleware(music.GetSongInfo))
 	musicGroup.GET("/list", deprecatedMiddleware(music.GetPlayedSongs))
-	musicGroup.GET("/next", deprecatedMiddleware(music.GetNextSong))
-	musicGroup.GET("/previous", deprecatedMiddleware(music.GetPreviousSong))
-	musicGroup.GET("/all", deprecatedMiddleware(music.GetAllSoundtracksRandom))
-	musicGroup.GET("/all/order", deprecatedMiddleware(music.GetAllSoundtracks))
-	musicGroup.GET("/all/random", deprecatedMiddleware(music.GetAllSoundtracksRandom))
-	musicGroup.PUT("/played", deprecatedMiddleware(music.PutPlayed))
-	musicGroup.GET("/addQue", deprecatedMiddleware(music.AddLatestToQue))
-	musicGroup.GET("/addPlayed", deprecatedMiddleware(music.AddLatestPlayed))
+	musicGroup.GET("/next", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetNextSong)))
+	musicGroup.GET("/previous", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetPreviousSong)))
+	musicGroup.GET("/all", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetAllSoundtracksRandom)))
+	musicGroup.GET("/all/order", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetAllSoundtracks)))
+	musicGroup.GET("/all/random", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetAllSoundtracksRandom)))
+	musicGroup.PUT("/played", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.PutPlayed)))
+	musicGroup.GET("/addQue", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.AddLatestToQue)))
+	musicGroup.GET("/addPlayed", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.AddLatestPlayed)))
 
 	// ============================================
 	// API v1 Routes with Token Authentication

internal/server/syncHandler.go

@@ -44,13 +44,9 @@ func (s *SyncHandler) SyncProgress(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /sync [get]
 func (s *SyncHandler) SyncSoundtracksNewOnlyChanges(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Warn("Syncing is already in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	logging.GetLogger().Info("Starting sync with only changes")
 	backend.Syncing = true
-	go backend.SyncSoundtracksNewOnlyChanges()
+	go backend.SyncSoundtracksOnlyChanges()
 	return ctx.JSON(http.StatusOK, "Start syncing soundtracks")
 }
 
@@ -64,13 +60,9 @@ func (s *SyncHandler) SyncSoundtracksNewOnlyChanges(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /sync/full [get]
 func (s *SyncHandler) SyncSoundtracksNewFull(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Warn("Syncing is already in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	logging.GetLogger().Info("Starting full sync")
 	backend.Syncing = true
-	go backend.SyncSoundtracksNewFull()
+	go backend.SyncSoundtracksFull()
 	return ctx.JSON(http.StatusOK, "Start syncing soundtracks full")
 }
 
@@ -84,10 +76,6 @@ func (s *SyncHandler) SyncSoundtracksNewFull(ctx *echo.Context) error {
 // @Failure 423 {string} string "Syncing is in progress"
 // @Router /sync/reset [get]
 func (s *SyncHandler) ResetDB(ctx *echo.Context) error {
-	if backend.Syncing {
-		logging.GetLogger().Warn("Cannot reset - syncing is in progress")
-		return ctx.JSON(http.StatusLocked, "Syncing is in progress")
-	}
 	logging.GetLogger().Info("Resetting soundtracks database")
 	backend.ResetDB()
 	return ctx.JSON(http.StatusOK, "Soundtracks and songs are deleted from the database")