arimelody.me/api/api.go

package api

import (
	"fmt"
	"net/http"
	"strings"

	"arimelody-web/admin"
	"arimelody-web/controller"

	"github.com/jmoiron/sqlx"
)

func Handler(db *sqlx.DB) http.Handler {
    mux := http.NewServeMux()

    // ACCOUNT ENDPOINTS

    /*
    // temporarily disabling these
    // accounts should really be handled via the frontend rn, and juggling
    // two different token bearer methods kinda sucks!!
    // i'll look into generating API tokens on the frontend in the future
    // TODO: generate API keys on the frontend

    mux.Handle("/v1/login", handleLogin())
    mux.Handle("/v1/register", handleAccountRegistration())
    mux.Handle("/v1/delete-account", handleDeleteAccount())
    */

    // ARTIST ENDPOINTS

    mux.Handle("/v1/artist/", http.StripPrefix("/v1/artist", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var artistID = strings.Split(r.URL.Path[1:], "/")[0]
        artist, err := controller.GetArtist(db, artistID)
        if err != nil {
            if strings.Contains(err.Error(), "no rows") {
                http.NotFound(w, r)
                return
            }
            fmt.Printf("FATAL: Error while retrieving artist %s: %s\n", artistID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        switch r.Method {
        case http.MethodGet:
            // GET /api/v1/artist/{id}
            ServeArtist(artist).ServeHTTP(w, r)
        case http.MethodPut:
            // PUT /api/v1/artist/{id} (admin)
            admin.RequireAccount(db, UpdateArtist(artist)).ServeHTTP(w, r)
        case http.MethodDelete:
            // DELETE /api/v1/artist/{id} (admin)
            admin.RequireAccount(db, DeleteArtist(artist)).ServeHTTP(w, r)
        default:
            http.NotFound(w, r)
        }
    })))
    mux.Handle("/v1/artist", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        switch r.Method {
        case http.MethodGet:
            // GET /api/v1/artist
            ServeAllArtists().ServeHTTP(w, r)
        case http.MethodPost:
            // POST /api/v1/artist (admin)
            admin.RequireAccount(db, CreateArtist()).ServeHTTP(w, r)
        default:
            http.NotFound(w, r)
        }
    }))

    // RELEASE ENDPOINTS

    mux.Handle("/v1/music/", http.StripPrefix("/v1/music", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var releaseID = strings.Split(r.URL.Path[1:], "/")[0]
        release, err := controller.GetRelease(db, releaseID, true)
        if err != nil {
            if strings.Contains(err.Error(), "no rows") {
                http.NotFound(w, r)
                return
            }
            fmt.Printf("FATAL: Error while retrieving release %s: %s\n", releaseID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        switch r.Method {
        case http.MethodGet:
            // GET /api/v1/music/{id}
            ServeRelease(release).ServeHTTP(w, r)
        case http.MethodPut:
            // PUT /api/v1/music/{id} (admin)
            admin.RequireAccount(db, UpdateRelease(release)).ServeHTTP(w, r)
        case http.MethodDelete:
            // DELETE /api/v1/music/{id} (admin)
            admin.RequireAccount(db, DeleteRelease(release)).ServeHTTP(w, r)
        default:
            http.NotFound(w, r)
        }
    })))
    mux.Handle("/v1/music", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        switch r.Method {
        case http.MethodGet:
            // GET /api/v1/music
            ServeCatalog().ServeHTTP(w, r)
        case http.MethodPost:
            // POST /api/v1/music (admin)
            admin.RequireAccount(db, CreateRelease()).ServeHTTP(w, r)
        default:
            http.NotFound(w, r)
        }
    }))

    // TRACK ENDPOINTS

    mux.Handle("/v1/track/", http.StripPrefix("/v1/track", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var trackID = strings.Split(r.URL.Path[1:], "/")[0]
        track, err := controller.GetTrack(db, trackID)
        if err != nil {
            if strings.Contains(err.Error(), "no rows") {
                http.NotFound(w, r)
                return
            }
            fmt.Printf("FATAL: Error while retrieving track %s: %s\n", trackID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        switch r.Method {
        case http.MethodGet:
            // GET /api/v1/track/{id} (admin)
            admin.RequireAccount(db, ServeTrack(track)).ServeHTTP(w, r)
        case http.MethodPut:
            // PUT /api/v1/track/{id} (admin)
            admin.RequireAccount(db, UpdateTrack(track)).ServeHTTP(w, r)
        case http.MethodDelete:
            // DELETE /api/v1/track/{id} (admin)
            admin.RequireAccount(db, DeleteTrack(track)).ServeHTTP(w, r)
        default:
            http.NotFound(w, r)
        }
    })))
    mux.Handle("/v1/track", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        switch r.Method {
        case http.MethodGet:
            // GET /api/v1/track (admin)
            admin.RequireAccount(db, ServeAllTracks()).ServeHTTP(w, r)
        case http.MethodPost:
            // POST /api/v1/track (admin)
            admin.RequireAccount(db, CreateTrack()).ServeHTTP(w, r)
        default:
            http.NotFound(w, r)
        }
    }))

    return mux
}