ari/arimelody.me
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

turns out rewriting all of your database code takes a while

Browse source
This commit is contained in:
ari melody 2024-09-01 04:43:32 +01:00
parent 1998a36d6d
commit 965d6f5c3e
30 changed files with 947 additions and 1036 deletions
Download patch file Download diff file Expand all files Collapse all files

11
admin/components/credits/editcredits.html
View file

@ -51,9 +51,8 @@
makeMagicList(creditList, ".credit");
creditList.addEventListener("htmx:afterSwap", e => {
const el = creditList.children[creditList.children.length - 1];
function rigCredit(el) {
console.log(el);
const artistID = el.dataset.artist;
const deleteBtn = el.querySelector("a.delete");
@ -64,6 +63,12 @@
el.addEventListener("dragstart", () => { el.classList.add("moving") });
el.addEventListener("dragend", () => { el.classList.remove("moving") });
}
[...creditList.querySelectorAll(".credit")].map(rigCredit);
creditList.addEventListener("htmx:afterSwap", () => {
rigCredit(creditList.children[creditList.children.length - 1]);
});
container.showModal();

4
admin/components/tracks/newtrack.html
View file

@ -1,7 +1,7 @@
<li class="track" data-track="{{.ID}}" data-title="{{.Title}}" data-number="{{.Number}}" draggable="true">
<li class="track" data-track="{{.ID}}" data-title="{{.Title}}" data-number="0" draggable="true">
<div>
<p class="track-name">
<span class="track-number">{{.Number}}</span>
<span class="track-number">0</span>
{{.Title}}
</p>
<a class="delete">Delete</a>

67
admin/http.go
View file

@ -12,8 +12,8 @@ import (
"arimelody.me/arimelody.me/discord"
"arimelody.me/arimelody.me/global"
musicController "arimelody.me/arimelody.me/music/controller"
musicModel "arimelody.me/arimelody.me/music/model"
musicDB "arimelody.me/arimelody.me/music/controller"
)
type loginData struct {
@ -29,18 +29,6 @@ func Handler() http.Handler {
mux.Handle("/static/", http.StripPrefix("/static", staticHandler()))
mux.Handle("/release/", MustAuthorise(http.StripPrefix("/release", serveRelease())))
mux.Handle("/track/", MustAuthorise(http.StripPrefix("/track", serveTrack())))
mux.Handle("/createtrack", MustAuthorise(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
track := musicModel.Track{ Title: "Untitled Track" }
trackID, err := musicController.CreateTrackDB(global.DB, &track)
if err != nil {
fmt.Printf("Failed to create track: %s\n", err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
track.ID = trackID
global.Tracks = append(global.Tracks, &track)
http.Redirect(w, r, fmt.Sprintf("/admin/track/%s", trackID), http.StatusTemporaryRedirect)
})))
mux.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/" {
http.NotFound(w, r)
@ -54,30 +42,55 @@ func Handler() http.Handler {
}
type (
Track struct {
*musicModel.Track
Lyrics template.HTML
// Number int
}
IndexData struct {
Releases []*musicModel.Release
Releases []musicModel.FullRelease
Artists []*musicModel.Artist
Tracks []Track
Tracks []musicModel.DisplayTrack
}
)
var tracks = []Track{}
for _, track := range global.Tracks {
if track.Release != nil { continue }
tracks = append(tracks, Track{
dbReleases, err := musicDB.GetAllReleases(global.DB)
if err != nil {
fmt.Printf("FATAL: Failed to pull releases: %s\n", err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
releases := []musicModel.FullRelease{}
for _, release := range dbReleases {
fullRelease, err := musicDB.GetFullRelease(global.DB, release)
if err != nil {
fmt.Printf("FATAL: Failed to pull full release data for %s: %s\n", release.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
releases = append(releases, *fullRelease)
}
artists, err := musicDB.GetAllArtists(global.DB)
if err != nil {
fmt.Printf("FATAL: Failed to pull artists: %s\n", err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
dbTracks, err := musicDB.GetOrphanTracks(global.DB)
if err != nil {
fmt.Printf("FATAL: Failed to pull orphan tracks: %s\n", err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
var tracks = []musicModel.DisplayTrack{}
for _, track := range dbTracks {
tracks = append(tracks, musicModel.DisplayTrack{
Track: track,
Lyrics: template.HTML(strings.Replace(track.Lyrics, "\n", "<br>", -1)),
})
}
err := pages["index"].Execute(w, IndexData{
Releases: global.Releases,
Artists: global.Artists,
err = pages["index"].Execute(w, IndexData{
Releases: releases,
Artists: artists,
Tracks: tracks,
})
if err != nil {

158
admin/releasehttp.go
View file

@ -2,83 +2,79 @@ 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
}
controller "arimelody.me/arimelody.me/music/controller"
)
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)
releaseID := slices[0]
release, err := controller.GetRelease(global.DB, releaseID)
if err != nil {
fmt.Printf("FATAL: Failed to pull release %s: %s\n", releaseID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
if release == nil {
http.NotFound(w, r)
return
}
authorised := GetSession(r) != nil
if !authorised && !release.Visible {
http.NotFound(w, r)
return
}
fullRelease, err := controller.GetFullRelease(global.DB, release)
if err != nil {
fmt.Printf("FATAL: Failed to pull full release data for %s: %s\n", release.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
if len(slices) > 1 {
switch slices[1] {
case "editcredits":
serveEditCredits(release).ServeHTTP(w, r)
serveEditCredits(fullRelease).ServeHTTP(w, r)
return
case "addcredit":
serveAddCredit(release).ServeHTTP(w, r)
serveAddCredit(fullRelease).ServeHTTP(w, r)
return
case "newcredit":
serveNewCredit().ServeHTTP(w, r)
return
case "editlinks":
serveEditLinks(release).ServeHTTP(w, r)
serveEditLinks(fullRelease).ServeHTTP(w, r)
return
case "edittracks":
serveEditTracks(release).ServeHTTP(w, r)
serveEditTracks(fullRelease).ServeHTTP(w, r)
return
case "addtrack":
serveAddTrack(release).ServeHTTP(w, r)
serveAddTrack(fullRelease).ServeHTTP(w, r)
return
case "newtrack":
serveNewTrack(release).ServeHTTP(w, r)
serveNewTrack().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})
err = pages["release"].Execute(w, fullRelease)
if err != nil {
fmt.Printf("Error rendering admin release page for %s: %s\n", id, err)
fmt.Printf("Error rendering admin release page for %s: %s\n", release.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
}
})
}
func serveEditCredits(release *model.Release) http.Handler {
func serveEditCredits(release *model.FullRelease) 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)
@ -89,20 +85,13 @@ func serveEditCredits(release *model.Release) http.Handler {
})
}
func serveAddCredit(release *model.Release) http.Handler {
func serveAddCredit(release *model.FullRelease) 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)
}
artists, err := controller.GetArtistsNotOnRelease(global.DB, release.Release)
if err != nil {
fmt.Printf("FATAL: Failed to pull artists not on %s: %s\n", release.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
type response struct {
@ -111,7 +100,7 @@ func serveAddCredit(release *model.Release) http.Handler {
}
w.Header().Set("Content-Type", "text/html")
err := components["addcredit"].Execute(w, response{
err = components["addcredit"].Execute(w, response{
ReleaseID: release.ID,
Artists: artists,
})
@ -124,23 +113,28 @@ func serveAddCredit(release *model.Release) http.Handler {
func serveNewCredit() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
artist := global.GetArtist(strings.Split(r.URL.Path, "/")[3])
artistID := strings.Split(r.URL.Path, "/")[3]
artist, err := controller.GetArtist(global.DB, artistID)
if err != nil {
fmt.Printf("FATAL: Failed to pull artists %s: %s\n", artistID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
if artist == nil {
http.NotFound(w, r)
return
}
w.Header().Set("Content-Type", "text/html")
err := components["newcredit"].Execute(w, artist)
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 {
func serveEditLinks(release *model.FullRelease) 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)
@ -148,49 +142,27 @@ func serveEditLinks(release *model.Release) http.Handler {
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 {
func serveEditTracks(release *model.FullRelease) 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)
err := components["edittracks"].Execute(w, release)
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 {
func serveAddTrack(release *model.FullRelease) 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)
}
tracks, err := controller.GetTracksNotOnRelease(global.DB, release.Release)
if err != nil {
fmt.Printf("FATAL: Failed to pull tracks not on %s: %s\n", release.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
type response struct {
@ -199,7 +171,7 @@ func serveAddTrack(release *model.Release) http.Handler {
}
w.Header().Set("Content-Type", "text/html")
err := components["addtrack"].Execute(w, response{
err = components["addtrack"].Execute(w, response{
ReleaseID: release.ID,
Tracks: tracks,
})
@ -211,24 +183,22 @@ func serveAddTrack(release *model.Release) http.Handler {
})
}
func serveNewTrack(release *model.Release) http.Handler {
func serveNewTrack() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
track := global.GetTrack(strings.Split(r.URL.Path, "/")[3])
trackID := strings.Split(r.URL.Path, "/")[3]
track, err := controller.GetTrack(global.DB, trackID)
if err != nil {
fmt.Printf("Error rendering new track component for %s: %s\n", trackID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
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,
})
err = components["newtrack"].Execute(w, track)
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)

25
admin/static/index.js
View file

@ -1,4 +1,5 @@
const newReleaseBtn = document.getElementById("create-release");
const newTrackBtn = document.getElementById("create-track");
newReleaseBtn.addEventListener("click", event => {
event.preventDefault();
@ -22,3 +23,27 @@ newReleaseBtn.addEventListener("click", event => {
console.error(err);
});
});
newTrackBtn.addEventListener("click", event => {
event.preventDefault();
const title = prompt("Enter an title for this track:");
if (title == null || title == "") return;
fetch("/api/v1/track", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({title})
}).then(res => {
res.text().then(text => {
if (res.ok) {
location = "/admin/track/" + text;
} else {
alert("Request failed: " + text);
console.error(text);
}
})
}).catch(err => {
alert("Failed to create release. Check the console for details.");
console.error(err);
});
});

33
admin/trackhttp.go
View file

@ -6,19 +6,48 @@ import (
"strings"
"arimelody.me/arimelody.me/global"
"arimelody.me/arimelody.me/music/model"
"arimelody.me/arimelody.me/music/controller"
)
func serveTrack() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
slices := strings.Split(r.URL.Path[1:], "/")
id := slices[0]
track := global.GetTrack(id)
track, err := music.GetTrack(global.DB, id)
if err != nil {
fmt.Printf("Error rendering admin track page for %s: %s\n", id, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
if track == nil {
http.NotFound(w, r)
return
}
err := pages["track"].Execute(w, track)
dbReleases, err := music.GetTrackReleases(global.DB, track)
if err != nil {
fmt.Printf("Error rendering admin track page for %s: %s\n", id, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
releases := []model.FullRelease{}
for _, release := range dbReleases {
fullRelease, err := music.GetFullRelease(global.DB, release)
if err != nil {
fmt.Printf("FATAL: Failed to pull full release data for %s: %s\n", release.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
releases = append(releases, *fullRelease)
}
type Track struct {
*model.Track
Releases []model.FullRelease
}
err = pages["track"].Execute(w, Track{ Track: track, Releases: releases })
if err != nil {
fmt.Printf("Error rendering admin track page for %s: %s\n", id, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)

6
admin/views/edit-track.html
View file

@ -43,8 +43,10 @@
<h2>Featured in</h2>
</div>
<div class="card releases">
{{if .Release}}
{{block "release" .Release}}{{end}}
{{if .Releases}}
{{range .Releases}}
{{block "release" .}}{{end}}
{{end}}
{{else}}
<p>This track isn't bound to a release.</p>
{{end}}

11
admin/views/index.html
View file

@ -9,7 +9,7 @@
<div class="card-title">
<h1>Releases</h1>
<a href="/admin/createrelease" class="create-btn" id="create-release">Create New</a>
<a class="create-btn" id="create-release">Create New</a>
</div>
<div class="card releases">
{{range .Releases}}
@ -22,7 +22,7 @@
<div class="card-title">
<h1>Artists</h1>
<a href="/admin/createartist" class="create-btn">Create New</a>
<a class="create-btn">Create New</a>
</div>
<div class="card artists">
{{range $Artist := .Artists}}
@ -38,7 +38,7 @@
<div class="card-title">
<h1>Tracks</h1>
<a href="/admin/createtrack" class="create-btn">Create New</a>
<a class="create-btn" id="create-track">Create New</a>
</div>
<div class="card tracks">
<p><em>"Orphaned" tracks that have not yet been bound to a release.</em></p>
@ -47,11 +47,6 @@
<div class="track">
<h2 class="track-title">
<a href="/admin/track/{{$Track.ID}}">{{$Track.Title}}</a>
{{if $Track.Release}}
<small class="track-album">{{$Track.Release.Title}}</small>
{{else}}
<small class="track-album empty">(no release)</small>
{{end}}
</h2>
{{if $Track.Description}}
<p class="track-description">{{$Track.Description}}</p>