turns out rewriting all of your database code takes a while

This commit is contained in:
ari melody 2024-09-01 04:43:32 +01:00
parent 1998a36d6d
commit 965d6f5c3e
30 changed files with 947 additions and 1036 deletions

View file

@ -7,35 +7,32 @@ import (
"arimelody.me/arimelody.me/global"
"arimelody.me/arimelody.me/music/model"
controller "arimelody.me/arimelody.me/music/controller"
)
func ServeAllTracks() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// type trackJSON struct {
// model.Track
// Release string `json:"release"`
// }
// var tracks = []trackJSON{}
//
// for _, track := range global.Tracks {
// for _, release := range global. {
// tracks = append(tracks, {
// track,
// Release
// })
// }
type track struct {
ID string `json:"id"`
Title string `json:"title"`
}
var tracks = []track{}
err := global.DB.Select(&tracks, "SELECT id, title FROM musictrack")
if err != nil {
fmt.Printf("FATAL: Failed to pull tracks from DB: %s\n", err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
}
w.Header().Add("Content-Type", "application/json")
err := json.NewEncoder(w).Encode(global.Tracks)
err = json.NewEncoder(w).Encode(tracks)
if err != nil {
fmt.Printf("FATAL: Failed to serve all tracks: %s\n", err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
})
}
func ServeTrack() http.Handler {
func ServeTrack(track model.Track) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/" {
ServeAllTracks().ServeHTTP(w, r)
@ -43,17 +40,35 @@ func ServeTrack() http.Handler {
}
var trackID = r.URL.Path[1:]
var track = global.GetTrack(trackID)
if track == nil {
var track = model.Track{}
err := global.DB.Get(&track, "SELECT * from musictrack WHERE id=$1", trackID)
if err != nil {
http.NotFound(w, r)
return
}
w.Header().Add("Content-Type", "application/json")
err := json.NewEncoder(w).Encode(track)
if err != nil {
var releases = []*model.Release{}
err = global.DB.Select(&releases,
"SELECT * FROM musicrelease JOIN musicreleasetrack AS mrt "+
"WHERE mrt.track=$1 "+
"ORDER BY release_date",
track.ID,
)
if err != nil {
fmt.Printf("FATAL: Failed to pull track releases for %s from DB: %s\n", trackID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
}
type response struct {
model.Track
Releases []*model.Release
}
w.Header().Add("Content-Type", "application/json")
err = json.NewEncoder(w).Encode(response{ track, releases })
if err != nil {
fmt.Printf("FATAL: Failed to serve track %s: %s\n", trackID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
})
}
@ -77,122 +92,92 @@ func CreateTrack() http.Handler {
return
}
trackID, err := controller.CreateTrackDB(global.DB, &track)
var trackID string
err = global.DB.Get(&trackID,
"INSERT INTO musictrack (title, description, lyrics, preview_url) "+
"VALUES ($1, $2, $3, $4) "+
"RETURNING id",
track.Title,
track.Description,
track.Lyrics,
track.PreviewURL)
if err != nil {
fmt.Printf("Failed to create track: %s\n", err)
fmt.Printf("FATAL: Failed to create track: %s\n", err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
track.ID = trackID
global.Tracks = append(global.Tracks, &track)
w.Header().Add("Content-Type", "application/json")
w.Header().Add("Content-Type", "text/plain")
w.WriteHeader(http.StatusCreated)
err = json.NewEncoder(w).Encode(track)
w.Write([]byte(trackID))
})
}
func UpdateTrack() http.Handler {
func UpdateTrack(track model.Track) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPut {
if r.Method != http.MethodPut || r.URL.Path == "/" {
http.NotFound(w, r)
return
}
if r.URL.Path == "/" {
http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
return
}
var data model.Track
err := json.NewDecoder(r.Body).Decode(&data)
var update model.Track
err := json.NewDecoder(r.Body).Decode(&update)
if err != nil {
fmt.Printf("Failed to update track: %s\n", err)
http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
return
}
var trackID = r.URL.Path[1:]
var track = global.GetTrack(trackID)
if track == nil {
http.Error(w, fmt.Sprintf("Track %s does not exist\n", trackID), http.StatusBadRequest)
if update.Title == "" {
http.Error(w, "Track title cannot be empty\n", http.StatusBadRequest)
return
}
data.ID = trackID
var trackID = r.URL.Path[1:]
var track = model.Track{}
err = global.DB.Get(&track, "SELECT * from musictrack WHERE id=$1", trackID)
if err != nil {
http.NotFound(w, r)
return
}
if data.Title == "" { data.Title = track.Title }
err = controller.UpdateTrackDB(global.DB, &data)
_, err = global.DB.Exec(
"UPDATE musictrack "+
"SET title=$2, description=$3, lyrics=$4, preview_url=$5 "+
"WHERE id=$1",
track.ID,
track.Title,
track.Description,
track.Lyrics,
track.PreviewURL)
if err != nil {
fmt.Printf("Failed to update track %s: %s\n", track.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
track.Title = data.Title
track.Description = data.Description
track.Lyrics = data.Lyrics
track.PreviewURL = data.PreviewURL
w.Header().Add("Content-Type", "application/json")
err = json.NewEncoder(w).Encode(track)
if err != nil {
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
})
}
func DeleteTrack() http.Handler {
func DeleteTrack(track model.Track) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodDelete {
if r.Method != http.MethodDelete || r.URL.Path == "/" {
http.NotFound(w, r)
return
}
if r.URL.Path == "/" {
http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
return
}
var trackID = r.URL.Path[1:]
var track = global.GetTrack(trackID)
if track == nil {
http.Error(w, fmt.Sprintf("Track %s does not exist\n", trackID), http.StatusBadRequest)
return
}
err := controller.DeleteTrackDB(global.DB, track)
_, err := global.DB.Exec(
"DELETE FROM musictrack "+
"WHERE id=$1",
trackID)
if err != nil {
fmt.Printf("Failed to delete track %s: %s\n", track.ID, err)
fmt.Printf("Failed to delete track %s: %s\n", trackID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
// clear track from releases
for _, release := range global.Releases {
release.Tracks = func () []*model.Track {
var tracks = []*model.Track{}
for _, t := range release.Tracks {
if t.ID == track.ID { continue }
tracks = append(tracks, t)
}
return tracks
}()
}
global.Tracks = func () []*model.Track {
var tracks = []*model.Track{}
for _, t := range global.Tracks {
if t.ID == track.ID { continue }
tracks = append(tracks, t)
}
return tracks
}()
w.WriteHeader(http.StatusOK)
w.Write([]byte(fmt.Sprintf("Track %s has been deleted\n", track.ID)))
})
}