arimelody.me/api/track.go

package api

import (
	"encoding/json"
	"fmt"
	"net/http"

	"arimelody.me/arimelody.me/global"
	"arimelody.me/arimelody.me/music/model"
)

func ServeAllTracks() http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        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(tracks)
		if err != nil {
            fmt.Printf("FATAL: Failed to serve all tracks: %s\n", err)
			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
		}
    })
}

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)
			return
		}

		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
		}

        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)
		}
	})
}

func CreateTrack() http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPost {
            http.NotFound(w, r)
            return
        }

        var track model.Track
        err := json.NewDecoder(r.Body).Decode(&track)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
            return
        }

        if track.Title == "" {
            http.Error(w, "Track title cannot be empty\n", http.StatusBadRequest)
            return
        }

        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("FATAL: Failed to create track: %s\n", err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        w.Header().Add("Content-Type", "text/plain")
        w.WriteHeader(http.StatusCreated)
        w.Write([]byte(trackID))
    })
}

func UpdateTrack(track model.Track) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPut || r.URL.Path == "/" {
            http.NotFound(w, r)
            return
        }

        var update model.Track
        err := json.NewDecoder(r.Body).Decode(&update)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
            return
        }

        if update.Title == "" {
            http.Error(w, "Track title cannot be empty\n", http.StatusBadRequest)
            return
        }

		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
		}

        _, 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
        }

        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)
        }
    })
}

func DeleteTrack(track model.Track) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodDelete || r.URL.Path == "/" {
            http.NotFound(w, r)
            return
        }

        var trackID = r.URL.Path[1:]
        _, err := global.DB.Exec(
            "DELETE FROM musictrack "+
            "WHERE id=$1",
            trackID)
        if err != nil {
            fmt.Printf("Failed to delete track %s: %s\n", trackID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}