arimelody.me/admin/releasehttp.go

package admin

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

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

type (
    gatewayTrack struct {
        *model.Track
        Lyrics template.HTML
        Number int
    }

    gatewayRelease struct {
        *model.Release
        Tracks []gatewayTrack
    }
)

func serveRelease() http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        slices := strings.Split(r.URL.Path[1:], "/")
        id := slices[0]
        release := global.GetRelease(id)
        if release == nil {
            http.NotFound(w, r)
            return
        }

        if len(slices) > 1 {
            switch slices[1] {
            case "editcredits":
                serveEditCredits(release).ServeHTTP(w, r)
                return
            case "addcredit":
                serveAddCredit(release).ServeHTTP(w, r)
                return
            case "newcredit":
                serveNewCredit().ServeHTTP(w, r)
                return
            case "editlinks":
                serveEditLinks(release).ServeHTTP(w, r)
                return
            case "edittracks":
                serveEditTracks(release).ServeHTTP(w, r)
                return
            case "addtrack":
                serveAddTrack(release).ServeHTTP(w, r)
                return
            case "newtrack":
                serveNewTrack(release).ServeHTTP(w, r)
                return
            }
            http.NotFound(w, r)
            return
        }

        tracks := []gatewayTrack{}
        for i, track := range release.Tracks {
            tracks = append(tracks, gatewayTrack{
                Track: track,
                Lyrics: template.HTML(strings.Replace(track.Lyrics, "\n", "<br>", -1)),
                Number: i + 1,
            })
        }

        err := pages["release"].Execute(w, gatewayRelease{release, tracks})
        if err != nil {
            fmt.Printf("Error rendering admin release page for %s: %s\n", id, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func serveEditCredits(release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/html")
        err := components["editcredits"].Execute(w, release)
        if err != nil {
            fmt.Printf("Error rendering edit credits component for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func serveAddCredit(release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var artists = []*model.Artist{}
        for _, artist := range global.Artists {
            var exists = false
            for _, credit := range release.Credits {
                if credit.Artist == artist {
                    exists = true
                    break
                }
            }
            if !exists {
                artists = append(artists, artist)
            }
        }

        type response struct {
            ReleaseID   string;
            Artists     []*model.Artist
        }

        w.Header().Set("Content-Type", "text/html")
        err := components["addcredit"].Execute(w, response{
            ReleaseID: release.ID,
            Artists: artists,
        })
        if err != nil {
            fmt.Printf("Error rendering add credits component for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func serveNewCredit() http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        artist := global.GetArtist(strings.Split(r.URL.Path, "/")[3])
        if artist == nil {
            http.NotFound(w, r)
            return
        }

        w.Header().Set("Content-Type", "text/html")
        err := components["newcredit"].Execute(w, artist)
        if err != nil {
            fmt.Printf("Error rendering new credit component for %s: %s\n", artist.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
        return
    })
}

func serveEditLinks(release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/html")
        err := components["editlinks"].Execute(w, release)
        if err != nil {
            fmt.Printf("Error rendering edit links component for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
        return
    })
}

func serveEditTracks(release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/html")
        type Track struct {
            *model.Track
            Number      int
        }
        type Release struct {
            *model.Release
            Tracks          []Track
        }
        var data = Release{ release, []Track{} }
        for i, track := range release.Tracks {
            data.Tracks = append(data.Tracks, Track{track, i + 1})
        }

        err := components["edittracks"].Execute(w, data)
        if err != nil {
            fmt.Printf("Error rendering edit tracks component for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
        return
    })
}

func serveAddTrack(release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var tracks = []*model.Track{}
        for _, track := range global.Tracks {
            var exists = false
            for _, t := range release.Tracks {
                if t == track {
                    exists = true
                    break
                }
            }
            if !exists {
                tracks = append(tracks, track)
            }
        }

        type response struct {
            ReleaseID   string;
            Tracks      []*model.Track
        }

        w.Header().Set("Content-Type", "text/html")
        err := components["addtrack"].Execute(w, response{
            ReleaseID: release.ID,
            Tracks: tracks,
        })
        if err != nil {
            fmt.Printf("Error rendering add tracks component for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
        return
    })
}

func serveNewTrack(release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        track := global.GetTrack(strings.Split(r.URL.Path, "/")[3])
        if track == nil {
            http.NotFound(w, r)
            return
        }

        type Track struct {
            *model.Track
            Number          int
        }

        w.Header().Set("Content-Type", "text/html")
        err := components["newtrack"].Execute(w, Track{
            track,
            len(release.Tracks) + 1,
        })
        if err != nil {
            fmt.Printf("Error rendering new track component for %s: %s\n", track.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
        return
    })
}