arimelody.me/api/release.go

package api

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

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

type releaseBodyJSON struct {
    ID              string              `json:"id"`
    Visible         bool                `json:"visible"`
    Title           string              `json:"title"`
    Description     string              `json:"description"`
    ReleaseType     model.ReleaseType   `json:"type"`
    ReleaseDate     time.Time           `json:"releaseDate"`
    Artwork         string              `json:"artwork"`
    Buyname         string              `json:"buyname"`
    Buylink         string              `json:"buylink"`
}

func ServeCatalog() http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        type CatalogItem struct {
            ID              string              `json:"id"`
            Title           string              `json:"title"`
            Description     string              `json:"description"`
            ReleaseType     model.ReleaseType   `json:"type"`
            ReleaseDate     time.Time           `json:"releaseDate"`
            Artwork         string              `json:"artwork"`
            Buyname         string              `json:"buyname"`
            Buylink         string              `json:"buylink"`
            Links        []*model.Link        `json:"links"`
        }

        catalog := []CatalogItem{}
        authorised := admin.GetSession(r) != nil
        for _, release := range global.Releases {
            if !release.Visible && !authorised {
                continue
            }
            catalog = append(catalog, CatalogItem{
                ID: release.ID,
                Title: release.Title,
                Description: release.Description,
                ReleaseType: release.ReleaseType,
                ReleaseDate: release.ReleaseDate,
                Artwork: release.Artwork,
                Buyname: release.Buyname,
                Buylink: release.Buylink,
                Links: release.Links,
            })
        }

        w.Header().Add("Content-Type", "application/json")
        err := json.NewEncoder(w).Encode(catalog)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }
    })
}

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

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

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

        if global.GetRelease(data.ID) != nil {
            http.Error(w, fmt.Sprintf("Release %s already exists\n", data.ID), http.StatusBadRequest)
            return
        }

        var release = model.Release{
            ID: data.ID,
            Visible: data.Visible,
            Title: data.Title,
            Description: data.Description,
            ReleaseType: data.ReleaseType,
            ReleaseDate: data.ReleaseDate,
            Artwork: data.Artwork,
            Buyname: data.Buyname,
            Buylink: data.Buylink,
            Links: []*model.Link{},
            Credits: []*model.Credit{},
            Tracks: []*model.Track{},
        }

        err = controller.CreateReleaseDB(global.DB, &release)
        if err != nil {
            fmt.Printf("Failed to create release %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        global.Releases = append([]*model.Release{&release}, global.Releases...)

        w.Header().Add("Content-Type", "application/json")
        w.WriteHeader(http.StatusCreated)
        err = json.NewEncoder(w).Encode(release)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }
    })
}

func UpdateRelease() http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path == "/" {
            http.NotFound(w, r)
            return
        }

        segments := strings.Split(r.URL.Path[1:], "/")
        var releaseID = segments[0]
        var release = global.GetRelease(releaseID)
        if release == nil {
            http.Error(w, fmt.Sprintf("Release %s does not exist\n", releaseID), http.StatusBadRequest)
            return
        }
        
        if len(segments) == 1 {
            var data releaseBodyJSON
            err := json.NewDecoder(r.Body).Decode(&data)
            if err != nil {
                fmt.Printf("Failed to update release: %s\n", err)
                http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
                return
            }

            if data.ID == "" { data.ID = release.ID }

            if data.Title == "" {
                http.Error(w, "Release title cannot be blank\n", http.StatusBadRequest)
                return
            }

            var new_release = model.Release{
                ID: data.ID,
                Visible: data.Visible,
                Title: data.Title,
                Description: data.Description,
                ReleaseType: data.ReleaseType,
                ReleaseDate: data.ReleaseDate,
                Artwork: data.Artwork,
                Buyname: data.Buyname,
                Buylink: data.Buylink,
            }

            err = controller.UpdateReleaseDB(global.DB, release)
            if err != nil {
                fmt.Printf("Failed to update release %s: %s\n", release.ID, err)
                http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
                return
            }

            release.ID = new_release.ID
            release.Visible = new_release.Visible
            release.Title = new_release.Title
            release.Description = new_release.Description
            release.ReleaseType = new_release.ReleaseType
            release.ReleaseDate = new_release.ReleaseDate
            release.Artwork = new_release.Artwork
            release.Buyname = new_release.Buyname
            release.Buylink = new_release.Buylink

            w.Header().Add("Content-Type", "application/json")
            err = json.NewEncoder(w).Encode(release)
            if err != nil {
                http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
                return
            }
        }

        if len(segments) == 2 {
            switch segments[1] {
            case "tracks":
                UpdateReleaseTracks(release).ServeHTTP(w, r)
            case "credits":
                UpdateReleaseCredits(release).ServeHTTP(w, r)
            case "links":
                UpdateReleaseLinks(release).ServeHTTP(w, r)
            }
            return
        }

        http.NotFound(w, r)
    })
}

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

        var trackIDs = []string{}
        err := json.NewDecoder(r.Body).Decode(&trackIDs)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
            return
        }

        var old_tracks = (*release).Tracks
        var new_tracks = []*model.Track{}
        for _, trackID := range trackIDs {
            var track = global.GetTrack(trackID)
            if track == nil {
                http.Error(w, fmt.Sprintf("Track %s does not exist\n", trackID), http.StatusBadRequest)
                return
            }
            new_tracks = append(new_tracks, track)
        }

        err = controller.UpdateReleaseTracksDB(global.DB, release, new_tracks)
        if err != nil {
            fmt.Printf("Failed to update tracks for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        release.Tracks = new_tracks

        // remove release from orphaned tracks
        for _, old_track := range old_tracks {
            var exists = false
            for _, track := range new_tracks {
                if track.ID == old_track.ID {
                    exists = true
                    break
                }
            }
            if !exists {
                old_track.Release = nil
            }
        }

        w.Header().Add("Content-Type", "application/json")
        w.WriteHeader(http.StatusOK)
        err = json.NewEncoder(w).Encode(release)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }
    })
}

func UpdateReleaseCredits(release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPut {
            http.NotFound(w, r)
            return
        }

        type creditJSON struct {
            Artist  string
            Role    string
            Primary bool
        }

        var list []creditJSON
        err := json.NewDecoder(r.Body).Decode(&list)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
            return
        }

        var credits = []*model.Credit{}
        for i, data := range list {
            if data.Artist == "" {
                http.Error(w, fmt.Sprintf("Artist ID cannot be blank (%d)", i), http.StatusBadRequest)
                return
            }

            for _, credit := range credits {
                if data.Artist == credit.Artist.ID {
                    http.Error(w, fmt.Sprintf("Artist %s credited more than once", data.Artist), http.StatusBadRequest)
                    return
                }
            }

            if data.Role == "" {
                http.Error(w, fmt.Sprintf("Artist role cannot be blank (%d)", i), http.StatusBadRequest)
                return
            }

            var artist = global.GetArtist(data.Artist)
            if artist == nil {
                http.Error(w, fmt.Sprintf("Artist %s does not exist\n", data.Artist), http.StatusBadRequest)
                return
            }

            credits = append(credits, &model.Credit{
                Artist: artist,
                Role: data.Role,
                Primary: data.Primary,
            })
        }

        err = controller.UpdateReleaseCreditsDB(global.DB, release, credits)
        if err != nil {
            fmt.Printf("Failed to update links %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        release.Credits = credits

        w.Header().Add("Content-Type", "application/json")
        w.WriteHeader(http.StatusOK)
        err = json.NewEncoder(w).Encode(release)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }
    })
}

func UpdateReleaseLinks(release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPut {
            http.NotFound(w, r)
            return
        }

        var links = []*model.Link{}
        err := json.NewDecoder(r.Body).Decode(&links)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
            return
        }

        err = controller.UpdateReleaseLinksDB(global.DB, release, links)
        if err != nil {
            fmt.Printf("Failed to update links %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        release.Links = links

        w.Header().Add("Content-Type", "application/json")
        w.WriteHeader(http.StatusOK)
        err = json.NewEncoder(w).Encode(release)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }
    })
}

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

        var releaseID = r.URL.Path[1:]
        var release = global.GetRelease(releaseID)
        if release == nil {
            http.Error(w, fmt.Sprintf("Release %s does not exist\n", releaseID), http.StatusBadRequest)
            return
        }

        err := controller.DeleteReleaseDB(global.DB, release)
        if err != nil {
            fmt.Printf("Failed to delete release %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        global.Releases = func () []*model.Release {
            var releases = []*model.Release{}
            for _, r := range global.Releases {
                if r.ID == release.ID { continue }
                releases = append(releases, r)
            }
            return releases            
        }()

        w.WriteHeader(http.StatusOK)
        w.Write([]byte(fmt.Sprintf("Release %s has been deleted\n", release.ID)))
    })
}