use servemux *properly* this time; better error handling for DB gets

admin/music/releasehttp.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"net/http"
 	"os"
-	"strings"
 
 	"arimelody-web/admin/core"
 	"arimelody-web/admin/templates"
@@ -47,14 +46,14 @@ func serveRelease(app *model.AppState, releaseID string) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
         release, err := controller.GetRelease(app.DB, releaseID, true)
         if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
             fmt.Fprintf(os.Stderr, "WARN: Failed to fetch full release data for %s: %s\n", releaseID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
             return
         }
+        if release == nil {
+            http.NotFound(w, r)
+            return
+        }
 
         session := r.Context().Value("session").(*model.Session)
 
@@ -80,26 +79,26 @@ func serveEditRelease(app *model.AppState, releaseID string) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
         release, err := controller.GetRelease(app.DB, releaseID, true)
         if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
             fmt.Fprintf(os.Stderr, "WARN: Failed to fetch full release data for %s: %s\n", releaseID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
             return
         }
+        if release == nil {
+            http.NotFound(w, r)
+            return
+        }
 
         mux := http.NewServeMux()
 
-        mux.Handle("/music/releases/{id}/editcredits", serveEditCredits(release))
+        mux.Handle("GET /music/releases/{id}/editcredits", serveEditCredits(release))
-        mux.Handle("/music/releases/{id}/addcredit", serveAddCredit(app, release))
+        mux.Handle("GET /music/releases/{id}/addcredit", serveAddCredit(app, release))
-        mux.Handle("/music/releases/{id}/newcredit", serveNewCredit(app))
+        mux.Handle("GET /music/releases/{id}/newcredit/{artistID}", serveNewCredit(app))
 
-        mux.Handle("/music/releases/{id}/editlinks", serveEditLinks(release))
+        mux.Handle("GET /music/releases/{id}/editlinks", serveEditLinks(release))
 
-        mux.Handle("/music/releases/{id}/edittracks", serveEditTracks(release))
+        mux.Handle("GET /music/releases/{id}/edittracks", serveEditTracks(release))
-        mux.Handle("/music/releases/{id}/addtrack", serveAddTrack(app, release))
+        mux.Handle("GET /music/releases/{id}/addtrack", serveAddTrack(app, release))
-        mux.Handle("/music/releases/{id}/newtrack", serveNewTrack(app))
+        mux.Handle("GET /music/releases/{id}/newtrack/{trackID}", serveNewTrack(app))
 
         mux.ServeHTTP(w, r)
     })
@@ -144,8 +143,7 @@ func serveAddCredit(app *model.AppState, release *model.Release) http.Handler {
 
 func serveNewCredit(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-        split := strings.Split(r.URL.Path, "/")
+        artistID := r.PathValue("artistID")
-        artistID := split[len(split) - 1]
         artist, err := controller.GetArtist(app.DB, artistID)
         if err != nil {
             fmt.Fprintf(os.Stderr, "WARN: Failed to fetch artist %s: %s\n", artistID, err)
@@ -221,8 +219,7 @@ func serveAddTrack(app *model.AppState, release *model.Release) http.Handler {
 
 func serveNewTrack(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-        split := strings.Split(r.URL.Path, "/")
+        trackID := r.PathValue("trackID")
-        trackID := split[len(split) - 1]
         track, err := controller.GetTrack(app.DB, trackID)
         if err != nil {
             fmt.Fprintf(os.Stderr, "WARN: Failed to fetch track %s: %s\n", trackID, err)

admin/static/edit-release.css

@@ -465,7 +465,7 @@ dialog div.dialog-actions {
 }
 
 #edittracks .track {
-    background-color: var(--bg-2);
+    background-color: var(--bg-1);
     transition: transform .2s ease-out, opacity .2s;
 }
 
@@ -488,7 +488,7 @@ dialog div.dialog-actions {
 }
 
 #edittracks .track:nth-child(even) {
-    background-color: var(--bg-1);
+    background-color: var(--bg-0);
 }
 
 #edittracks .track-number {
@@ -510,17 +510,17 @@ dialog div.dialog-actions {
     padding: .5em;
     display: flex;
     gap: .5em;
-    background-color: var(--bg-0);
+    background-color: var(--bg-1);
     cursor: pointer;
     transition: background-color .1s ease-out, color .1s ease-out;
 }
 
 #addtrack ul li.new-track:nth-child(even) {
-    background: color-mix(in srgb, var(--bg-0) 95%, #fff);
+    background-color: var(--bg-0);
 }
 
 #addtrack ul li.new-track:hover {
-    background: color-mix(in srgb, var(--bg-0) 90%, #fff);
+    background-color: var(--bg-2);
 }
 
 @media only screen and (max-width: 1105px) {

api/api.go

@@ -18,142 +18,50 @@ func Handler(app *model.AppState) http.Handler {
 
     // ARTIST ENDPOINTS
 
-    mux.Handle("/v1/artist/{id}", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    mux.Handle("GET /v1/artist/{id}", ServeArtist(app))
-        var artistID = r.PathValue("id")
+    mux.Handle("PUT /v1/artist/{id}", requireAccount(UpdateArtist(app)))
-        artist, err := controller.GetArtist(app.DB, artistID)
+    mux.Handle("DELETE /v1/artist/{id}", requireAccount(DeleteArtist(app)))
-        if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
-            fmt.Printf("WARN: Error while retrieving artist %s: %s\n", artistID, err)
-            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-            return
-        }
 
-        switch r.Method {
+    mux.Handle("GET /v1/artist/", ServeAllArtists(app))
-        case http.MethodGet:
+    mux.Handle("GET /v1/artist", ServeAllArtists(app))
-            // GET /api/v1/artist/{id}
+    mux.Handle("POST /v1/artist/", requireAccount(CreateArtist(app)))
-            ServeArtist(app, artist).ServeHTTP(w, r)
+    mux.Handle("POST /v1/artist", requireAccount(CreateArtist(app)))
-        case http.MethodPut:
-            // PUT /api/v1/artist/{id} (admin)
-            requireAccount(UpdateArtist(app, artist)).ServeHTTP(w, r)
-        case http.MethodDelete:
-            // DELETE /api/v1/artist/{id} (admin)
-            requireAccount(DeleteArtist(app, artist)).ServeHTTP(w, r)
-        default:
-            http.NotFound(w, r)
-        }
-    }))
-    artistIndexHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-        switch r.Method {
-        case http.MethodGet:
-            // GET /api/v1/artist
-            ServeAllArtists(app).ServeHTTP(w, r)
-        case http.MethodPost:
-            // POST /api/v1/artist (admin)
-            requireAccount(CreateArtist(app)).ServeHTTP(w, r)
-        default:
-            http.NotFound(w, r)
-        }
-    })
-    mux.Handle("/v1/artist/", artistIndexHandler)
-    mux.Handle("/v1/artist", artistIndexHandler)
 
     // RELEASE ENDPOINTS
 
-    mux.Handle("/v1/music/{id}", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    mux.Handle("GET /v1/music/{id}", ServeRelease(app))
-        var releaseID = r.PathValue("id")
+    mux.Handle("PUT /v1/music/{id}", requireAccount(UpdateRelease(app)))
-        release, err := controller.GetRelease(app.DB, releaseID, true)
+    mux.Handle("DELETE /v1/music/{id}", requireAccount(DeleteRelease(app)))
-        if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
-            fmt.Printf("WARN: Error while retrieving release %s: %s\n", releaseID, err)
-            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-            return
-        }
 
-        switch r.Method {
+    mux.Handle("PUT /v1/music/{id}/tracks", requireAccount(UpdateReleaseTracks(app)))
-        case http.MethodGet:
+    mux.Handle("PUT /v1/music/{id}/credits", requireAccount(UpdateReleaseCredits(app)))
-            // GET /api/v1/music/{id}
+    mux.Handle("PUT /v1/music/{id}/links", requireAccount(UpdateReleaseLinks(app)))
-            ServeRelease(app, release).ServeHTTP(w, r)
+
-        case http.MethodPut:
+    mux.Handle("GET /v1/music/", ServeCatalog(app))
-            // PUT /api/v1/music/{id} (admin)
+    mux.Handle("GET /v1/music", ServeCatalog(app))
-            requireAccount(UpdateRelease(app, release)).ServeHTTP(w, r)
+    mux.Handle("POST /v1/music/", requireAccount(CreateRelease(app)))
-        case http.MethodDelete:
+    mux.Handle("POST /v1/music", requireAccount(CreateRelease(app)))
-            // DELETE /api/v1/music/{id} (admin)
-            requireAccount(DeleteRelease(app, release)).ServeHTTP(w, r)
-        default:
-            http.NotFound(w, r)
-        }
-    }))
-    musicIndexHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-        switch r.Method {
-        case http.MethodGet:
-            // GET /api/v1/music
-            ServeCatalog(app).ServeHTTP(w, r)
-        case http.MethodPost:
-            // POST /api/v1/music (admin)
-            requireAccount(CreateRelease(app)).ServeHTTP(w, r)
-        default:
-            http.NotFound(w, r)
-        }
-    })
-    mux.Handle("/v1/music/", musicIndexHandler)
-    mux.Handle("/v1/music", musicIndexHandler)
 
     // TRACK ENDPOINTS
 
-    mux.Handle("/v1/track/{id}", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    mux.Handle("GET /v1/track/{id}", requireAccount(ServeTrack(app)))
-        var trackID = r.PathValue("id")
+    mux.Handle("PUT /v1/track/{id}", requireAccount(UpdateTrack(app)))
-        track, err := controller.GetTrack(app.DB, trackID)
+    mux.Handle("DELETE /v1/track/{id}", requireAccount(DeleteTrack(app)))
-        if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
-            fmt.Printf("WARN: Error while retrieving track %s: %s\n", trackID, err)
-            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-            return
-        }
 
-        switch r.Method {
+    mux.Handle("GET /v1/track/", requireAccount(ServeAllTracks(app)))
-        case http.MethodGet:
+    mux.Handle("GET /v1/track", requireAccount(ServeAllTracks(app)))
-            // GET /api/v1/track/{id} (admin)
+    mux.Handle("POST /v1/track/", requireAccount(CreateTrack(app)))
-            requireAccount(ServeTrack(app, track)).ServeHTTP(w, r)
+    mux.Handle("POST /v1/track", requireAccount(CreateTrack(app)))
-        case http.MethodPut:
-            // PUT /api/v1/track/{id} (admin)
-            requireAccount(UpdateTrack(app, track)).ServeHTTP(w, r)
-        case http.MethodDelete:
-            // DELETE /api/v1/track/{id} (admin)
-            requireAccount(DeleteTrack(app, track)).ServeHTTP(w, r)
-        default:
-            http.NotFound(w, r)
-        }
-    }))
-    trackIndexHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-        switch r.Method {
-        case http.MethodGet:
-            // GET /api/v1/track (admin)
-            requireAccount(ServeAllTracks(app)).ServeHTTP(w, r)
-        case http.MethodPost:
-            // POST /api/v1/track (admin)
-            requireAccount(CreateTrack(app)).ServeHTTP(w, r)
-        default:
-            http.NotFound(w, r)
-        }
-    })
-    mux.Handle("/v1/track/", trackIndexHandler)
-    mux.Handle("/v1/track", trackIndexHandler)
 
     // BLOG ENDPOINTS
 
     mux.Handle("GET /v1/blog/{id}", ServeBlog(app))
     mux.Handle("PUT /v1/blog/{id}", requireAccount(UpdateBlog(app)))
     mux.Handle("DELETE /v1/blog/{id}", requireAccount(DeleteBlog(app)))
+
+    mux.Handle("GET /v1/blog/", ServeAllBlogs(app))
     mux.Handle("GET /v1/blog", ServeAllBlogs(app))
+    mux.Handle("POST /v1/blog/", requireAccount(CreateBlog(app)))
     mux.Handle("POST /v1/blog", requireAccount(CreateBlog(app)))
 
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

api/artist.go

@@ -35,8 +35,20 @@ func ServeAllArtists(app *model.AppState) http.Handler {
     })
 }
 
-func ServeArtist(app *model.AppState, artist *model.Artist) http.Handler {
+func ServeArtist(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        var artistID = r.PathValue("id")
+        artist, err := controller.GetArtist(app.DB, artistID)
+        if err != nil {
+            fmt.Printf("WARN: Error while retrieving artist %s: %s\n", artistID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if artist == nil {
+            http.NotFound(w, r)
+            return
+        }
+
         type (
             creditJSON struct {
                 ID              string      `json:"id"`
@@ -121,11 +133,23 @@ func CreateArtist(app *model.AppState) http.Handler {
     })
 }
 
-func UpdateArtist(app *model.AppState, artist *model.Artist) http.Handler {
+func UpdateArtist(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
         session := r.Context().Value("session").(*model.Session)
 
-        err := json.NewDecoder(r.Body).Decode(&artist)
+        var artistID = r.PathValue("id")
+        artist, err := controller.GetArtist(app.DB, artistID)
+        if err != nil {
+            fmt.Printf("WARN: Error while retrieving artist %s: %s\n", artistID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if artist == nil {
+            http.NotFound(w, r)
+            return
+        }
+
+        err = json.NewDecoder(r.Body).Decode(&artist)
         if err != nil {
             fmt.Printf("WARN: Failed to update artist: %s\n", err)
             http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
@@ -158,10 +182,6 @@ func UpdateArtist(app *model.AppState, artist *model.Artist) http.Handler {
 
         err = controller.UpdateArtist(app.DB, artist)
         if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
             fmt.Printf("WARN: Failed to update artist %s: %s\n", artist.ID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
         }
@@ -170,16 +190,24 @@ func UpdateArtist(app *model.AppState, artist *model.Artist) http.Handler {
     })
 }
 
-func DeleteArtist(app *model.AppState, artist *model.Artist) http.Handler {
+func DeleteArtist(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
         session := r.Context().Value("session").(*model.Session)
 
-        err := controller.DeleteArtist(app.DB, artist.ID)
+        var artistID = r.PathValue("id")
+        artist, err := controller.GetArtist(app.DB, artistID)
         if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
+            fmt.Printf("WARN: Error while retrieving artist %s: %s\n", artistID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if artist == nil {
             http.NotFound(w, r)
             return
         }
+
+        err = controller.DeleteArtist(app.DB, artist.ID)
+        if err != nil {
             fmt.Printf("WARN: Failed to delete artist %s: %s\n", artist.ID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
         }

api/blog.go

@@ -66,10 +66,6 @@ func ServeBlog(app *model.AppState) http.Handler {
 
         blog, err := controller.GetBlogPost(app.DB, blogID)
         if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
             fmt.Fprintf(os.Stderr, "WARN: Failed to fetch blog post %s: %v\n", blogID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
             return
@@ -150,10 +146,6 @@ func UpdateBlog(app *model.AppState) http.Handler {
 
         blog, err := controller.GetBlogPost(app.DB, blogID)
         if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
             fmt.Fprintf(os.Stderr, "WARN: Failed to fetch blog post %s: %v\n", blogID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
             return
@@ -212,10 +204,6 @@ func UpdateBlog(app *model.AppState) http.Handler {
 
         err = controller.UpdateBlogPost(app.DB, blogID, blog)
         if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
             fmt.Printf("WARN: Failed to update release %s: %v\n", blogID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
         }

api/release.go

@@ -15,8 +15,20 @@ import (
     "arimelody-web/model"
 )
 
-func ServeRelease(app *model.AppState, release *model.Release) http.Handler {
+func ServeRelease(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        var releaseID = r.PathValue("id")
+        release, err := controller.GetRelease(app.DB, releaseID, true)
+        if err != nil {
+            fmt.Printf("WARN: Error while retrieving release %s: %s\n", releaseID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if release == nil {
+            http.NotFound(w, r)
+            return
+        }
+
         // only allow authorised users to view hidden releases
         privileged := false
         if !release.Visible {
@@ -119,7 +131,7 @@ func ServeRelease(app *model.AppState, release *model.Release) http.Handler {
         w.Header().Add("Content-Type", "application/json")
         encoder := json.NewEncoder(w)
         encoder.SetIndent("", "\t")
-        err := encoder.Encode(response)
+        err = encoder.Encode(response)
         if err != nil {
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
             return
@@ -238,35 +250,23 @@ func CreateRelease(app *model.AppState) http.Handler {
     })
 }
 
-func UpdateRelease(app *model.AppState, release *model.Release) http.Handler {
+func UpdateRelease(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
         session := r.Context().Value("session").(*model.Session)
 
-        if r.URL.Path == "/" {
+        var releaseID = r.PathValue("id")
+        release, err := controller.GetRelease(app.DB, releaseID, true)
+        if err != nil {
+            fmt.Printf("WARN: Error while retrieving release %s: %s\n", releaseID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if release == nil {
             http.NotFound(w, r)
             return
         }
 
-        segments := strings.Split(r.URL.Path[1:], "/")
+        err = json.NewDecoder(r.Body).Decode(&release)
-
-        if len(segments) == 2 {
-            switch segments[1] {
-            case "tracks":
-                UpdateReleaseTracks(app, release).ServeHTTP(w, r)
-            case "credits":
-                UpdateReleaseCredits(app, release).ServeHTTP(w, r)
-            case "links":
-                UpdateReleaseLinks(app, release).ServeHTTP(w, r)
-            }
-            return
-        }
-        
-        if len(segments) > 2 {
-            http.NotFound(w, r)
-            return
-        }
-
-        err := json.NewDecoder(r.Body).Decode(&release)
         if err != nil {
             fmt.Printf("WARN: Failed to update release %s: %s\n", release.ID, err)
             http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
@@ -299,10 +299,6 @@ func UpdateRelease(app *model.AppState, release *model.Release) http.Handler {
 
         err = controller.UpdateRelease(app.DB, release)
         if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
             fmt.Printf("WARN: Failed to update release %s: %s\n", release.ID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
         }
@@ -311,12 +307,24 @@ func UpdateRelease(app *model.AppState, release *model.Release) http.Handler {
     })
 }
 
-func UpdateReleaseTracks(app *model.AppState, release *model.Release) http.Handler {
+func UpdateReleaseTracks(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
         session := r.Context().Value("session").(*model.Session)
 
+        var releaseID = r.PathValue("id")
+        release, err := controller.GetRelease(app.DB, releaseID, true)
+        if err != nil {
+            fmt.Printf("WARN: Error while retrieving release %s: %s\n", releaseID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if release == nil {
+            http.NotFound(w, r)
+            return
+        }
+
         var trackIDs = []string{}
-        err := json.NewDecoder(r.Body).Decode(&trackIDs)
+        err = json.NewDecoder(r.Body).Decode(&trackIDs)
         if err != nil {
             http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
             return
@@ -328,10 +336,6 @@ func UpdateReleaseTracks(app *model.AppState, release *model.Release) http.Handl
                 http.Error(w, "Release cannot have duplicate tracks", http.StatusBadRequest)
                 return
             }
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
             fmt.Printf("WARN: Failed to update tracks for %s: %s\n", release.ID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
         }
@@ -340,17 +344,29 @@ func UpdateReleaseTracks(app *model.AppState, release *model.Release) http.Handl
     })
 }
 
-func UpdateReleaseCredits(app *model.AppState, release *model.Release) http.Handler {
+func UpdateReleaseCredits(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
         session := r.Context().Value("session").(*model.Session)
 
+        var releaseID = r.PathValue("id")
+        release, err := controller.GetRelease(app.DB, releaseID, true)
+        if err != nil {
+            fmt.Printf("WARN: Error while retrieving release %s: %s\n", releaseID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if release == nil {
+            http.NotFound(w, r)
+            return
+        }
+
         type creditJSON struct {
             Artist  string
             Role    string
             Primary bool
         }
         var data []creditJSON
-        err := json.NewDecoder(r.Body).Decode(&data)
+        err = json.NewDecoder(r.Body).Decode(&data)
         if err != nil {
             http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
             return
@@ -373,10 +389,6 @@ func UpdateReleaseCredits(app *model.AppState, release *model.Release) http.Hand
                 http.Error(w, "Artists may only be credited once", http.StatusBadRequest)
                 return
             }
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
             fmt.Printf("WARN: Failed to update credits for %s: %s\n", release.ID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
         }
@@ -385,12 +397,24 @@ func UpdateReleaseCredits(app *model.AppState, release *model.Release) http.Hand
     })
 }
 
-func UpdateReleaseLinks(app *model.AppState, release *model.Release) http.Handler {
+func UpdateReleaseLinks(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
         session := r.Context().Value("session").(*model.Session)
 
+        var releaseID = r.PathValue("id")
+        release, err := controller.GetRelease(app.DB, releaseID, true)
+        if err != nil {
+            fmt.Printf("WARN: Error while retrieving release %s: %s\n", releaseID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if release == nil {
+            http.NotFound(w, r)
+            return
+        }
+
         var links = []*model.Link{}
-        err := json.NewDecoder(r.Body).Decode(&links)
+        err = json.NewDecoder(r.Body).Decode(&links)
         if err != nil {
             http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
             return
@@ -402,10 +426,6 @@ func UpdateReleaseLinks(app *model.AppState, release *model.Release) http.Handle
                 http.Error(w, "Release cannot have duplicate link names", http.StatusBadRequest)
                 return
             }
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
             fmt.Printf("WARN: Failed to update links for %s: %s\n", release.ID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
         }
@@ -414,16 +434,24 @@ func UpdateReleaseLinks(app *model.AppState, release *model.Release) http.Handle
     })
 }
 
-func DeleteRelease(app *model.AppState, release *model.Release) http.Handler {
+func DeleteRelease(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
         session := r.Context().Value("session").(*model.Session)
 
-        err := controller.DeleteRelease(app.DB, release.ID)
+        var releaseID = r.PathValue("id")
+        release, err := controller.GetRelease(app.DB, releaseID, true)
         if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
+            fmt.Printf("WARN: Error while retrieving release %s: %s\n", releaseID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if release == nil {
             http.NotFound(w, r)
             return
         }
+
+        err = controller.DeleteRelease(app.DB, release.ID)
+        if err != nil {
             fmt.Printf("WARN: Failed to delete release %s: %s\n", release.ID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
         }

api/track.go

@@ -50,8 +50,20 @@ func ServeAllTracks(app *model.AppState) http.Handler {
     })
 }
 
-func ServeTrack(app *model.AppState, track *model.Track) http.Handler {
+func ServeTrack(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        var trackID = r.PathValue("id")
+        track, err := controller.GetTrack(app.DB, trackID)
+        if err != nil {
+            fmt.Printf("WARN: Error while retrieving track %s: %s\n", trackID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if track == nil {
+            http.NotFound(w, r)
+            return
+        }
+
         dbReleases, err := controller.GetTrackReleases(app.DB, track.ID, false)
         if err != nil {
             fmt.Printf("WARN: Failed to pull track releases for %s from DB: %s\n", track.ID, err)
@@ -105,16 +117,23 @@ func CreateTrack(app *model.AppState) http.Handler {
     })
 }
 
-func UpdateTrack(app *model.AppState, track *model.Track) http.Handler {
+func UpdateTrack(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-        if r.URL.Path == "/" {
+        session := r.Context().Value("session").(*model.Session)
+
+        var trackID = r.PathValue("id")
+        track, err := controller.GetTrack(app.DB, trackID)
+        if err != nil {
+            fmt.Printf("WARN: Error while retrieving track %s: %s\n", trackID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if track == nil {
             http.NotFound(w, r)
             return
         }
 
-        session := r.Context().Value("session").(*model.Session)
+        err = json.NewDecoder(r.Body).Decode(&track)
-
-        err := json.NewDecoder(r.Body).Decode(&track)
         if err != nil {
             http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
             return
@@ -144,17 +163,23 @@ func UpdateTrack(app *model.AppState, track *model.Track) http.Handler {
     })
 }
 
-func DeleteTrack(app *model.AppState, track *model.Track) http.Handler {
+func DeleteTrack(app *model.AppState) http.Handler {
     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-        if r.URL.Path == "/" {
+        session := r.Context().Value("session").(*model.Session)
+
+        var trackID = r.PathValue("id")
+        track, err := controller.GetTrack(app.DB, trackID)
+        if err != nil {
+            fmt.Printf("WARN: Error while retrieving track %s: %s\n", trackID, err)
+            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+            return
+        }
+        if track == nil {
             http.NotFound(w, r)
             return
         }
 
-        session := r.Context().Value("session").(*model.Session)
+        err = controller.DeleteTrack(app.DB, trackID)
-
-        var trackID = r.URL.Path[1:]
-        err := controller.DeleteTrack(app.DB, trackID)
         if err != nil {
             fmt.Printf("WARN: Failed to delete track %s: %s\n", trackID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)

controller/account.go

@@ -23,9 +23,7 @@ func GetAccountByID(db *sqlx.DB, id string) (*model.Account, error) {
 
     err := db.Get(&account, "SELECT * FROM account WHERE id=$1", id)
     if err != nil {
-        if strings.Contains(err.Error(), "no rows") {
+        if strings.Contains(err.Error(), "no rows") { return nil, nil }
-            return nil, nil
-        }
         return nil, err
     }
 
@@ -37,9 +35,7 @@ func GetAccountByUsername(db *sqlx.DB, username string) (*model.Account, error)
 
     err := db.Get(&account, "SELECT * FROM account WHERE username=$1", username)
     if err != nil {
-        if strings.Contains(err.Error(), "no rows") {
+        if strings.Contains(err.Error(), "no rows") { return nil, nil }
-            return nil, nil
-        }
         return nil, err
     }
 
@@ -51,9 +47,7 @@ func GetAccountByEmail(db *sqlx.DB, email string) (*model.Account, error) {
 
     err := db.Get(&account, "SELECT * FROM account WHERE email=$1", email)
     if err != nil {
-        if strings.Contains(err.Error(), "no rows") {
+        if strings.Contains(err.Error(), "no rows") { return nil, nil }
-            return nil, nil
-        }
         return nil, err
     }
 
@@ -67,9 +61,7 @@ func GetAccountBySession(db *sqlx.DB, sessionToken string) (*model.Account, erro
 
     err := db.Get(&account, "SELECT account.* FROM account JOIN token ON id=account WHERE token=$1", sessionToken)
     if err != nil {
-        if strings.Contains(err.Error(), "no rows") {
+        if strings.Contains(err.Error(), "no rows") { return nil, nil }
-            return nil, nil
-        }
         return nil, err
     }
 

controller/artist.go

@@ -2,6 +2,7 @@ package controller
 
 import (
 	"arimelody-web/model"
+	"strings"
 
 	"github.com/jmoiron/sqlx"
 )
@@ -13,6 +14,7 @@ func GetArtist(db *sqlx.DB, id string) (*model.Artist, error) {
 
     err := db.Get(&artist, "SELECT * FROM artist WHERE id=$1", id)
     if err != nil {
+        if strings.Contains(err.Error(), "no rows") { return nil, nil }
         return nil, err
     }
 

controller/blog.go

@@ -3,6 +3,7 @@ package controller
 import (
 	"arimelody-web/model"
 	"database/sql"
+	"strings"
 
 	"github.com/jmoiron/sqlx"
 )
@@ -22,6 +23,7 @@ func GetBlogPost(db *sqlx.DB, id string) (*model.BlogPost, error) {
         id,
     )
     if err != nil {
+        if strings.Contains(err.Error(), "no rows") { return nil, nil }
         return nil, err
     }
 

controller/invite.go

@@ -16,9 +16,7 @@ func GetInvite(db *sqlx.DB, code string) (*model.Invite, error) {
 
     err := db.Get(&invite, "SELECT * FROM invite WHERE code=$1", code)
     if err != nil {
-        if strings.Contains(err.Error(), "no rows") {
+        if strings.Contains(err.Error(), "no rows") { return nil, nil }
-            return nil, nil
-        }
         return nil, err
     }
 
@@ -32,7 +30,7 @@ func CreateInvite(db *sqlx.DB, length int, lifetime time.Duration) (*model.Invit
     }
     
     code := []byte{}
-    for i := 0; i < length; i++ {
+    for range length {
         code = append(code, inviteChars[rand.Intn(len(inviteChars) - 1)])
     }
     invite.Code = string(code)

controller/release.go

@@ -14,6 +14,7 @@ func GetRelease(db *sqlx.DB, id string, full bool) (*model.Release, error) {
 
     err := db.Get(&release, "SELECT * FROM musicrelease WHERE id=$1", id)
     if err != nil {
+        if strings.Contains(err.Error(), "no rows") { return nil, nil }
         return nil, err
     }
 
@@ -117,9 +118,7 @@ func GetLatestRelease(db *sqlx.DB) (*model.Release, error) {
 
     err := db.Get(&release, "SELECT * FROM musicrelease WHERE visible=true ORDER BY release_date DESC LIMIT 1")
     if err != nil {
-        if strings.Contains(err.Error(), "no rows") {
+        if strings.Contains(err.Error(), "no rows") { return nil, nil }
-            return nil, nil
-        }
         return nil, err
     }
 

controller/totp.go

@@ -121,9 +121,7 @@ func GetTOTP(db *sqlx.DB, accountID string, name string) (*model.TOTP, error) {
         name,
     )
     if err != nil {
-        if strings.Contains(err.Error(), "no rows") {
+        if strings.Contains(err.Error(), "no rows") { return nil, nil }
-            return nil, nil
-        }
         return nil, err
     }
 

controller/track.go

@@ -2,6 +2,7 @@ package controller
 
 import (
 	"arimelody-web/model"
+	"strings"
 
 	"github.com/jmoiron/sqlx"
 )
@@ -11,9 +12,9 @@ import (
 func GetTrack(db *sqlx.DB, id string) (*model.Track, error) {
     var track = model.Track{}
 
-    stmt, _ := db.Preparex("SELECT * FROM musictrack WHERE id=$1")
+    err := db.Get("SELECT * FROM musictrack WHERE id=$1", id)
-    err := stmt.Get(&track, id)
     if err != nil {
+        if strings.Contains(err.Error(), "no rows") { return nil, nil }
         return nil, err
     }
     return &track, nil

log/log.go

@@ -114,17 +114,6 @@ func (self *Logger) Search(levelFilters []LogLevel, typeFilters []string, conten
         conditions,
     )
 
-    /*
-    fmt.Printf("%s (", query)
-    for i, param := range params {
-        fmt.Print(param)
-        if i < len(params) - 1 {
-            fmt.Print(", ")
-        }
-    }
-    fmt.Print(")\n")
-    */
-
     err := self.DB.Select(&logs, query, params...)
     if err != nil {
         return nil, err

view/blog.go

@@ -6,7 +6,6 @@ import (
 	"net/http"
 	"os"
 	"slices"
-	"strings"
 
 	"arimelody-web/controller"
 	"arimelody-web/model"
@@ -59,10 +58,6 @@ func BlogHandler(app *model.AppState) http.Handler {
 	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
         posts, err := controller.GetBlogPosts(app.DB, true, -1, 0)
         if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
 			fmt.Fprintf(os.Stderr, "WARN: Failed to fetch blog posts: %v\n", err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
             return
@@ -111,10 +106,6 @@ func ServeBlogPost(app *model.AppState, blogPostID string) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		blog, err := controller.GetBlogPost(app.DB, blogPostID)
         if err != nil {
-            if strings.Contains(err.Error(), "no rows") {
-                http.NotFound(w, r)
-                return
-            }
 			fmt.Fprintf(os.Stderr, "WARN: Failed to fetch blog post %s: %v\n", blogPostID, err)
             http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
             return