398 lines
14 KiB
Go
398 lines
14 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/fs"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"arimelody.me/arimelody.me/admin"
|
|
"arimelody.me/arimelody.me/global"
|
|
"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"`
|
|
ReleaseType model.ReleaseType `json:"type"`
|
|
ReleaseDate time.Time `json:"releaseDate"`
|
|
Artwork string `json:"artwork"`
|
|
Buylink string `json:"buylink"`
|
|
}
|
|
|
|
releases := []*model.Release{}
|
|
err := global.DB.Select(&releases, "SELECT * FROM musicrelease ORDER BY release_date DESC")
|
|
if err != nil {
|
|
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
catalog := []catalogItem{}
|
|
authorised := admin.GetSession(r) != nil
|
|
for _, release := range releases {
|
|
if !release.Visible && !authorised {
|
|
continue
|
|
}
|
|
catalog = append(catalog, catalogItem{
|
|
ID: release.ID,
|
|
Title: release.Title,
|
|
ReleaseType: release.ReleaseType,
|
|
ReleaseDate: release.ReleaseDate,
|
|
Artwork: release.Artwork,
|
|
Buylink: release.Buylink,
|
|
})
|
|
}
|
|
|
|
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 }
|
|
|
|
var release = model.Release{
|
|
ID: data.ID,
|
|
Visible: false,
|
|
Title: title,
|
|
Description: description,
|
|
ReleaseType: releaseType,
|
|
ReleaseDate: releaseDate,
|
|
Artwork: artwork,
|
|
Buyname: buyname,
|
|
Buylink: buylink,
|
|
}
|
|
|
|
_, err = global.DB.Exec(
|
|
"INSERT INTO musicrelease "+
|
|
"(id, visible, title, description, type, release_date, artwork, buyname, buylink) "+
|
|
"VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)",
|
|
release.ID,
|
|
release.Visible,
|
|
release.Title,
|
|
release.Description,
|
|
release.ReleaseType,
|
|
release.ReleaseDate.Format("2006-01-02 15:04:05"),
|
|
release.Artwork,
|
|
release.Buyname,
|
|
release.Buylink)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "duplicate key") {
|
|
http.Error(w, fmt.Sprintf("Release %s already exists\n", data.ID), http.StatusBadRequest)
|
|
return
|
|
}
|
|
fmt.Printf("Failed to create release %s: %s\n", release.ID, err)
|
|
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Add("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusCreated)
|
|
err = json.NewEncoder(w).Encode(release)
|
|
if err != nil {
|
|
fmt.Printf("WARN: Release %s created, but failed to send JSON response: %s\n", release.ID, err)
|
|
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
|
|
}
|
|
})
|
|
}
|
|
|
|
func UpdateRelease(release model.Release) 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 exists int
|
|
err := global.DB.Get(&exists, "SELECT count(*) FROM musicrelease WHERE id=$1", releaseID)
|
|
if err != nil {
|
|
fmt.Printf("Failed to update release: %s\n", err)
|
|
http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
|
|
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
|
|
}
|
|
|
|
if len(segments) > 2 {
|
|
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 != "" { release.ID = data.ID }
|
|
if data.Visible != nil { release.Visible = *data.Visible }
|
|
if data.Title != nil { release.Title = *data.Title }
|
|
if data.Description != nil { release.Description = *data.Description }
|
|
if data.ReleaseType != nil { release.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
|
|
}
|
|
release.ReleaseDate = newDate
|
|
}
|
|
if data.Artwork != nil {
|
|
if strings.Contains(*data.Artwork, ";base64,") {
|
|
var artworkDirectory = filepath.Join("uploads", "musicart")
|
|
filename, err := HandleImageUpload(data.Artwork, artworkDirectory, data.ID)
|
|
|
|
// clean up files with this ID and different extensions
|
|
err = filepath.Walk(artworkDirectory, func(path string, info fs.FileInfo, err error) error {
|
|
if path == filepath.Join(artworkDirectory, filename) { return nil }
|
|
|
|
withoutExt := strings.TrimSuffix(path, filepath.Ext(path))
|
|
if withoutExt != filepath.Join(artworkDirectory, release.ID) { return nil }
|
|
|
|
return os.Remove(path)
|
|
})
|
|
if err != nil {
|
|
fmt.Printf("WARN: Error while cleaning up artwork files: %s\n", err)
|
|
}
|
|
|
|
release.Artwork = fmt.Sprintf("/uploads/musicart/%s", filename)
|
|
} else {
|
|
release.Artwork = *data.Artwork
|
|
}
|
|
}
|
|
|
|
if data.Buyname != nil { release.Buyname = *data.Buyname }
|
|
if data.Buylink != nil { release.Buylink = *data.Buylink }
|
|
|
|
_, err = global.DB.Exec(
|
|
"UPDATE musicrelease SET "+
|
|
"visible=$2, title=$3, description=$4, type=$5, release_date=$6, artwork=$7, buyname=$8, buylink=$9 "+
|
|
"WHERE id=$1",
|
|
release.ID,
|
|
release.Visible,
|
|
release.Title,
|
|
release.Description,
|
|
release.ReleaseType,
|
|
release.ReleaseDate.Format("2006-01-02 15:04:05"),
|
|
release.Artwork,
|
|
release.Buyname,
|
|
release.Buylink)
|
|
if err != nil {
|
|
fmt.Printf("FATAL: Failed to update release %s: %s\n", release.ID, err)
|
|
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
|
|
}
|
|
})
|
|
}
|
|
|
|
func UpdateReleaseTracks(release model.Release) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
var trackIDs = []string{}
|
|
err := json.NewDecoder(r.Body).Decode(&trackIDs)
|
|
if err != nil {
|
|
http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
tx := global.DB.MustBegin()
|
|
tx.MustExec("DELETE FROM musicreleasetrack WHERE release=$1", release.ID)
|
|
for i, trackID := range trackIDs {
|
|
tx.MustExec(
|
|
"INSERT INTO musicreleasetrack "+
|
|
"(release, track, number) "+
|
|
"VALUES ($1, $2, $3)",
|
|
release.ID,
|
|
trackID,
|
|
i)
|
|
}
|
|
err = tx.Commit()
|
|
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)
|
|
}
|
|
})
|
|
}
|
|
|
|
func UpdateReleaseCredits(release model.Release) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
type creditJSON struct {
|
|
Artist string
|
|
Role string
|
|
Primary bool
|
|
}
|
|
var data []creditJSON
|
|
err := json.NewDecoder(r.Body).Decode(&data)
|
|
if err != nil {
|
|
http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// clear duplicates
|
|
type Credit struct {
|
|
Role string
|
|
Primary bool
|
|
}
|
|
var credits = map[string]Credit{}
|
|
for _, credit := range data {
|
|
credits[credit.Artist] = Credit{
|
|
Role: credit.Role,
|
|
Primary: credit.Primary,
|
|
}
|
|
}
|
|
|
|
tx := global.DB.MustBegin()
|
|
tx.MustExec("DELETE FROM musiccredit WHERE release=$1", release.ID)
|
|
for artistID := range credits {
|
|
if credits[artistID].Role == "" {
|
|
http.Error(w, fmt.Sprintf("Artist role cannot be blank (%s)", artistID), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
var exists int
|
|
_ = global.DB.Get(&exists, "SELECT count(*) FROM artist WHERE id=$1", artistID)
|
|
if exists == 0 {
|
|
http.Error(w, fmt.Sprintf("Artist %s does not exist\n", artistID), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
tx.MustExec(
|
|
"INSERT INTO musiccredit "+
|
|
"(release, artist, role, is_primary) "+
|
|
"VALUES ($1, $2, $3, $4)",
|
|
release.ID,
|
|
artistID,
|
|
credits[artistID].Role,
|
|
credits[artistID].Primary)
|
|
}
|
|
err = tx.Commit()
|
|
if err != nil {
|
|
fmt.Printf("Failed to update links for %s: %s\n", release.ID, err)
|
|
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
|
|
}
|
|
})
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
tx := global.DB.MustBegin()
|
|
tx.MustExec("DELETE FROM musiclink WHERE release=$1", release.ID)
|
|
for _, link := range links {
|
|
tx.MustExec(
|
|
"INSERT INTO musiclink "+
|
|
"(release, name, url) "+
|
|
"VALUES ($1, $2, $3)",
|
|
release.ID,
|
|
link.Name,
|
|
link.URL)
|
|
}
|
|
err = tx.Commit()
|
|
if err != nil {
|
|
fmt.Printf("Failed to update links for %s: %s\n", release.ID, err)
|
|
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
|
|
}
|
|
})
|
|
}
|
|
|
|
func DeleteRelease(release model.Release) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
_, err := global.DB.Exec("DELETE FROM musicrelease WHERE id=$1", release.ID)
|
|
if err != nil {
|
|
fmt.Printf("Failed to delete release %s: %s\n", release.ID, err)
|
|
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
|
|
}
|
|
})
|
|
}
|