arimelody.me/api/release.go

508 lines
18 KiB
Go

package api
import (
"bufio"
"encoding/base64"
"encoding/json"
"fmt"
"io/fs"
"net/http"
"os"
"path/filepath"
"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 *string `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
}
title := data.ID
if data.Title != nil && *data.Title != "" {
title = *data.Title
}
description := ""
if data.Description != nil && *data.Description != "" { description = *data.Description }
releaseType := model.Single
if data.ReleaseType != nil && *data.ReleaseType != "" { releaseType = *data.ReleaseType }
releaseDate := time.Time{}
if data.ReleaseDate != nil && *data.ReleaseDate != "" {
releaseDate, err = time.Parse("2006-01-02T15:04", *data.ReleaseDate)
if err != nil {
http.Error(w, "Invalid release date", http.StatusBadRequest)
return
}
} else {
releaseDate = time.Date(time.Now().Year(), time.Now().Month(), time.Now().Day(), 0, 0, 0, 0, time.UTC)
}
artwork := "/img/default-cover-art.png"
if data.Artwork != nil && *data.Artwork != "" { artwork = *data.Artwork }
buyname := ""
if data.Buyname != nil && *data.Buyname != "" { buyname = *data.Buyname }
buylink := ""
if data.Buylink != nil && *data.Buylink != "" { buylink = *data.Buylink }
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: false,
Title: title,
Description: description,
ReleaseType: releaseType,
ReleaseDate: releaseDate,
Artwork: artwork,
Buyname: buyname,
Buylink: 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
}
var update = *release
if data.ID != "" { update.ID = data.ID }
if data.Visible != nil { update.Visible = *data.Visible }
if data.Title != nil { update.Title = *data.Title }
if data.Description != nil { update.Description = *data.Description }
if data.ReleaseType != nil { update.ReleaseType = *data.ReleaseType }
if data.ReleaseDate != nil {
newDate, err := time.Parse("2006-01-02T15:04", *data.ReleaseDate)
if err != nil {
http.Error(w, "Invalid release date", http.StatusBadRequest)
return
}
update.ReleaseDate = newDate
}
if data.Artwork != nil {
if strings.Contains(*data.Artwork, ";base64,") {
split := strings.Split(*data.Artwork, ";base64,")
header := split[0]
imageData, err := base64.StdEncoding.DecodeString(split[1])
ext, _ := strings.CutPrefix(header, "data:image/")
switch ext {
case "png":
case "jpg":
case "jpeg":
default:
http.Error(w, "Invalid image type. Allowed: .png, .jpg, .jpeg", http.StatusBadRequest)
return
}
artworkDirectory := filepath.Join("uploads", "musicart")
// ensure directory exists
os.MkdirAll(artworkDirectory, os.ModePerm)
imagePath := filepath.Join(artworkDirectory, fmt.Sprintf("%s.%s", update.ID, ext))
file, err := os.Create(imagePath)
if err != nil {
fmt.Printf("FATAL: Failed to create file %s: %s\n", imagePath, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
defer file.Close()
buffer := bufio.NewWriter(file)
_, err = buffer.Write(imageData)
if err != nil {
fmt.Printf("FATAL: Failed to write to file %s: %s\n", imagePath, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
if err := buffer.Flush(); err != nil {
fmt.Printf("FATAL: Failed to flush data to file %s: %s\n", imagePath, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
// clean up files with this ID and different extensions
err = filepath.Walk(artworkDirectory, func(path string, info fs.FileInfo, err error) error {
if path == imagePath { return nil }
withoutExt := strings.TrimSuffix(path, filepath.Ext(path))
if withoutExt != filepath.Join(artworkDirectory, update.ID) { return nil }
return os.Remove(path)
})
if err != nil {
fmt.Printf("WARN: Error while cleaning up artwork files: %s\n", err)
}
fmt.Printf("Artwork for %s updated.\n", update.ID)
update.Artwork = fmt.Sprintf("/uploads/musicart/%s.%s", update.ID, ext)
} else {
update.Artwork = *data.Artwork
}
}
if data.Buyname != nil { update.Buyname = *data.Buyname }
if data.Buylink != nil { update.Buylink = *data.Buylink }
err = controller.UpdateReleaseDB(global.DB, &update)
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 = update.ID
release.Visible = update.Visible
release.Title = update.Title
release.Description = update.Description
release.ReleaseType = update.ReleaseType
release.ReleaseDate = update.ReleaseDate
release.Artwork = update.Artwork
release.Buyname = update.Buyname
release.Buylink = update.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
}
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)
track.Release = release
}
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)))
})
}