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

lots of post-DB cleanup

Browse source
This commit is contained in:
ari melody 2024-09-02 00:15:23 +01:00
parent 965d6f5c3e
commit c9d950d2b2
Signed by: ari
GPG key ID: CF99829C92678188
23 changed files with 412 additions and 550 deletions
Download patch file Download diff file Expand all files Collapse all files

31
music/controller/artist.go
View file

@ -29,14 +29,14 @@ func GetAllArtists(db *sqlx.DB) ([]*model.Artist, error) {
return artists, nil
}
func GetArtistsNotOnRelease(db *sqlx.DB, release *model.Release) ([]*model.Artist, error) {
func GetArtistsNotOnRelease(db *sqlx.DB, releaseID string) ([]*model.Artist, error) {
var artists = []*model.Artist{}
err := db.Select(&artists,
"SELECT * FROM artist "+
"WHERE id NOT IN "+
"(SELECT artist FROM musiccredit WHERE release=$1)",
release.ID)
releaseID)
if err != nil {
return nil, err
}
@ -44,6 +44,33 @@ func GetArtistsNotOnRelease(db *sqlx.DB, release *model.Release) ([]*model.Artis
return artists, nil
}
func GetArtistCredits(db *sqlx.DB, artistID string) ([]*model.Credit, error) {
type DBCredit struct {
Release string
Artist string
Role string
Primary bool `db:"is_primary"`
}
var dbCredits []DBCredit
err := db.Select(&dbCredits, "SELECT * FROM musiccredit WHERE artist=$1", artistID)
if err != nil {
return nil, err
}
var credits []*model.Credit
for _, credit := range dbCredits {
credits = append(credits, &model.Credit{
Release: model.Release{ ID: credit.Release },
Artist: model.Artist{ ID: credit.Artist },
Role: credit.Role,
Primary: credit.Primary,
})
}
return credits, nil
}
func CreateArtist(db *sqlx.DB, artist *model.Artist) error {
_, err := db.Exec(
"INSERT INTO artist (id, name, website, avatar) "+

71
music/controller/credit.go
View file

@ -1,71 +0,0 @@
package music
import (
"arimelody.me/arimelody.me/music/model"
"github.com/jmoiron/sqlx"
)
// DATABASE
func GetReleaseCredits(db *sqlx.DB, release *model.Release) ([]model.Credit, error) {
var credits = []model.Credit{}
err := db.Select(&credits,
"SELECT artist.*,role,is_primary FROM musiccredit "+
"JOIN artist ON artist=id "+
"WHERE release=$1",
release.ID,
)
if err != nil {
return nil, err
}
return credits, nil
}
func CreateCredit(db *sqlx.DB, releaseID string, artistID string, credit *model.Credit) (error) {
_, err := db.Exec(
"INSERT INTO musiccredit (release, artist, role, is_primary) "+
"VALUES ($1, $2, $3, $4)",
releaseID,
artistID,
credit.Role,
credit.Primary,
)
if err != nil {
return err
}
return nil
}
func UpdateCredit(db *sqlx.DB, releaseID string, artistID string, credit *model.Credit) (error) {
_, err := db.Exec(
"UPDATE musiccredit SET "+
"role=$3, is_primary=$4 "+
"WHERE release=$1, artist=$2",
releaseID,
artistID,
credit.Role,
credit.Primary,
)
if err != nil {
return err
}
return nil
}
func DeleteCredit(db *sqlx.DB, releaseID string, artistID string) (error) {
_, err := db.Exec(
"DELETE FROM musiccredit "+
"WHERE release=$1, artist=$2",
releaseID,
artistID,
)
if err != nil {
return err
}
return nil
}

64
music/controller/link.go
View file

@ -1,64 +0,0 @@
package music
import (
"arimelody.me/arimelody.me/music/model"
"github.com/jmoiron/sqlx"
)
// DATABASE
func GetReleaseLinks(db *sqlx.DB, release *model.Release) ([]model.Link, error) {
var links = []model.Link{}
err := db.Select(&links, "SELECT name,url FROM musiclink WHERE release=$1", release.ID)
if err != nil {
return nil, err
}
return links, nil
}
func CreateLink(db *sqlx.DB, releaseID string, link *model.Link) (error) {
_, err := db.Exec(
"INSERT INTO musiclink (release, name, url) "+
"VALUES ($1, $2, $3)",
releaseID,
link.Name,
link.URL,
)
if err != nil {
return err
}
return nil
}
func UpdateLink(db *sqlx.DB, releaseID string, link *model.Link) (error) {
_, err := db.Exec(
"UPDATE musiclink SET "+
"name=$2, url=$3 "+
"WHERE release=$1",
releaseID,
link.Name,
link.URL,
)
if err != nil {
return err
}
return nil
}
func DeleteLink(db *sqlx.DB, releaseID string, link *model.Link) (error) {
_, err := db.Exec(
"DELETE FROM musiclink "+
"WHERE release=$1, name=$2",
releaseID,
link.Name,
)
if err != nil {
return err
}
return nil
}

129
music/controller/release.go
View file

@ -1,6 +1,9 @@
package music
import (
"errors"
"fmt"
"arimelody.me/arimelody.me/music/model"
"github.com/jmoiron/sqlx"
)
@ -27,28 +30,11 @@ func GetAllReleases(db *sqlx.DB) ([]*model.Release, error) {
return releases, nil
}
func GetReleaseTracks(db *sqlx.DB, release *model.Release) ([]*model.Track, error) {
var tracks = []*model.Track{}
err := db.Select(&tracks,
"SELECT musictrack.* FROM musictrack "+
"JOIN musicreleasetrack ON track=id "+
"WHERE release=$1 "+
"ORDER BY number ASC",
release.ID,
)
if err != nil {
return nil, err
}
return tracks, nil
}
func CreateRelease(db *sqlx.DB, release *model.Release) error {
_, err := 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)",
"(id, visible, title, description, type, release_date, artwork, buyname, buylink, copyright, copyrighturl) "+
"VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)",
release.ID,
release.Visible,
release.Title,
@ -58,6 +44,8 @@ func CreateRelease(db *sqlx.DB, release *model.Release) error {
release.Artwork,
release.Buyname,
release.Buylink,
release.Copyright,
release.CopyrightURL,
)
if err != nil {
return err
@ -69,7 +57,7 @@ func CreateRelease(db *sqlx.DB, release *model.Release) error {
func UpdateRelease(db *sqlx.DB, release *model.Release) error {
_, err := db.Exec(
"UPDATE musicrelease SET "+
"visible=$2, title=$3, description=$4, type=$5, release_date=$6, artwork=$7, buyname=$8, buylink=$9 "+
"visible=$2, title=$3, description=$4, type=$5, release_date=$6, artwork=$7, buyname=$8, buylink=$9, copyright=$10, copyrighturl=$11 "+
"WHERE id=$1",
release.ID,
release.Visible,
@ -80,6 +68,8 @@ func UpdateRelease(db *sqlx.DB, release *model.Release) error {
release.Artwork,
release.Buyname,
release.Buylink,
release.Copyright,
release.CopyrightURL,
)
if err != nil {
return err
@ -88,7 +78,7 @@ func UpdateRelease(db *sqlx.DB, release *model.Release) error {
return nil
}
func UpdateReleaseTracks(db *sqlx.DB, release *model.Release, new_tracks []*model.Track) error {
func UpdateReleaseTracks(db *sqlx.DB, release *model.Release, new_tracks []string) error {
_, err := db.Exec(
"DELETE FROM musicreleasetrack "+
"WHERE release=$1",
@ -98,13 +88,13 @@ func UpdateReleaseTracks(db *sqlx.DB, release *model.Release, new_tracks []*mode
return err
}
for i, track := range new_tracks {
for i, trackID := range new_tracks {
_, err = db.Exec(
"INSERT INTO musicreleasetrack "+
"(release, track, number) "+
"VALUES ($1, $2, $3)",
release.ID,
track.ID,
trackID,
i,
)
if err != nil {
@ -115,7 +105,7 @@ func UpdateReleaseTracks(db *sqlx.DB, release *model.Release, new_tracks []*mode
return nil
}
func UpdateReleaseCredits(db *sqlx.DB, release *model.Release, new_credits []*model.Credit) error {
func UpdateReleaseCredits(db *sqlx.DB, release *model.Release, new_credits []model.Credit) error {
_, err := db.Exec(
"DELETE FROM musiccredit "+
"WHERE release=$1",
@ -183,17 +173,32 @@ func DeleteRelease(db *sqlx.DB, release *model.Release) error {
return nil
}
func GetFullRelease(db *sqlx.DB, release *model.Release) (*model.FullRelease, error) {
// get credits
credits, err := GetReleaseCredits(db, release)
func GetFullRelease(db *sqlx.DB, releaseID string) (*model.FullRelease, error) {
// get release
release, err := GetRelease(db, releaseID)
if err != nil {
return nil, err
}
// get tracks
dbTracks, err := GetReleaseTracks(db, release)
// get credits
credits, err := GetReleaseCredits(db, releaseID)
if err != nil {
return nil, err
return nil, errors.New(fmt.Sprintf("Credits: %s", err))
}
// get artists
for i, credit := range credits {
artist, err := GetArtist(db, credit.Artist.ID)
if err != nil {
return nil, errors.New(fmt.Sprintf("FATAL: Failed to serve release %s: Artists: %s\n", release.ID, err))
}
credits[i].Artist = *artist
}
// get tracks
dbTracks, err := GetReleaseTracks(db, releaseID)
if err != nil {
return nil, errors.New(fmt.Sprintf("Tracks: %s", err))
}
tracks := []model.DisplayTrack{}
for i, track := range dbTracks {
@ -201,9 +206,9 @@ func GetFullRelease(db *sqlx.DB, release *model.Release) (*model.FullRelease, er
}
// get links
links, err := GetReleaseLinks(db, release)
links, err := GetReleaseLinks(db, releaseID)
if err != nil {
return nil, err
return nil, errors.New(fmt.Sprintf("Links: %s", err))
}
return &model.FullRelease{
@ -213,3 +218,63 @@ func GetFullRelease(db *sqlx.DB, release *model.Release) (*model.FullRelease, er
Links: links,
}, nil
}
func GetReleaseTracks(db *sqlx.DB, releaseID string) ([]model.Track, error) {
var tracks = []model.Track{}
err := db.Select(&tracks,
"SELECT musictrack.* FROM musictrack "+
"JOIN musicreleasetrack ON track=id "+
"WHERE release=$1 "+
"ORDER BY number ASC",
releaseID,
)
if err != nil {
return nil, err
}
return tracks, nil
}
func GetReleaseCredits(db *sqlx.DB, releaseID string) ([]model.Credit, error) {
type DBCredit struct {
Release string
Artist string
Role string
Primary bool `db:"is_primary"`
}
var dbCredits []DBCredit
err := db.Select(&dbCredits,
"SELECT musiccredit.* FROM musiccredit "+
"JOIN artist ON artist=id "+
"WHERE release=$1",
releaseID,
)
if err != nil {
return nil, err
}
var credits []model.Credit
for _, credit := range dbCredits {
credits = append(credits, model.Credit{
Release: model.Release{ ID: credit.Release },
Artist: model.Artist{ ID: credit.Artist },
Role: credit.Role,
Primary: credit.Primary,
})
}
return credits, nil
}
func GetReleaseLinks(db *sqlx.DB, releaseID string) ([]model.Link, error) {
var links = []model.Link{}
err := db.Select(&links, "SELECT name,url FROM musiclink WHERE release=$1", releaseID)
if err != nil {
return nil, err
}
return links, nil
}

16
music/controller/track.go
View file

@ -40,14 +40,14 @@ func GetOrphanTracks(db *sqlx.DB) ([]*model.Track, error) {
return tracks, nil
}
func GetTracksNotOnRelease(db *sqlx.DB, release *model.Release) ([]*model.Track, error) {
func GetTracksNotOnRelease(db *sqlx.DB, releaseID string) ([]*model.Track, error) {
var tracks = []*model.Track{}
err := db.Select(&tracks,
"SELECT * FROM musictrack "+
"WHERE id NOT IN "+
"(SELECT track FROM musicreleasetrack WHERE release=$1)",
release.ID)
releaseID)
if err != nil {
return nil, err
}
@ -55,15 +55,15 @@ func GetTracksNotOnRelease(db *sqlx.DB, release *model.Release) ([]*model.Track,
return tracks, nil
}
func GetTrackReleases(db *sqlx.DB, track *model.Track) ([]*model.Release, error) {
var releases = []*model.Release{}
func GetTrackReleases(db *sqlx.DB, trackID string) ([]model.ReleaseShorthand, error) {
var releases = []model.ReleaseShorthand{}
err := db.Select(&releases,
"SELECT musicrelease.* FROM musicrelease "+
"SELECT id,title,type,release_date,artwork,buylink FROM musicrelease "+
"JOIN musicreleasetrack ON release=id "+
"WHERE track=$1 "+
"ORDER BY release_date",
track.ID,
trackID,
)
if err != nil {
return nil, err
@ -123,11 +123,11 @@ func UpdateTrack(db *sqlx.DB, track *model.Track) error {
return nil
}
func DeleteTrack(db *sqlx.DB, track *model.Track) error {
func DeleteTrack(db *sqlx.DB, trackID string) error {
_, err := db.Exec(
"DELETE FROM musictrack "+
"WHERE id=$1",
track.ID,
trackID,
)
if err != nil {
return err

3
music/model/credit.go
View file

@ -1,7 +1,8 @@
package model
type Credit struct {
Artist `json:"artist"`
Release Release `json:"release"`
Artist Artist `json:"artist"`
Role string `json:"role"`
Primary bool `json:"primary" db:"is_primary"`
}

37
music/model/release.go
View file

@ -8,24 +8,33 @@ type (
ReleaseType string
Release struct {
ID string `json:"id"`
Visible bool `json:"visible"`
Title string `json:"title"`
Description string `json:"description"`
ReleaseType ReleaseType `json:"type" db:"type"`
ReleaseDate time.Time `json:"releaseDate" db:"release_date"`
Artwork string `json:"artwork"`
Buyname string `json:"buyname"`
Buylink string `json:"buylink"`
Copyright string `json:"copyright" db:"copyright"`
CopyrightURL string `json:"copyrightURL" db:"copyrighturl"`
ID string `json:"id"`
Visible bool `json:"visible"`
Title string `json:"title"`
Description string `json:"description"`
ReleaseType ReleaseType `json:"type" db:"type"`
ReleaseDate time.Time `json:"releaseDate" db:"release_date"`
Artwork string `json:"artwork"`
Buyname string `json:"buyname"`
Buylink string `json:"buylink"`
Copyright string `json:"copyright" db:"copyright"`
CopyrightURL string `json:"copyrightURL" db:"copyrighturl"`
}
FullRelease struct {
*Release
Tracks []DisplayTrack
Credits []Credit
Links []Link
Tracks []DisplayTrack `json:"tracks"`
Credits []Credit `json:"credits"`
Links []Link `json:"links"`
}
ReleaseShorthand struct {
ID string `json:"id"`
Title string `json:"title"`
ReleaseType ReleaseType `json:"type" db:"type"`
ReleaseDate time.Time `json:"releaseDate" db:"release_date"`
Artwork string `json:"artwork"`
Buylink string `json:"buylink"`
}
)

6
music/model/track.go
View file

@ -10,14 +10,14 @@ type (
ID string `json:"id"`
Title string `json:"title"`
Description string `json:"description"`
Lyrics string `json:"lyrics"`
Lyrics string `json:"lyrics" db:"lyrics"`
PreviewURL string `json:"previewURL" db:"preview_url"`
}
DisplayTrack struct {
*Track
Lyrics template.HTML
Number int
Lyrics template.HTML `json:"lyrics"`
Number int `json:"-"`
}
)

2
music/view/music.go
View file

@ -48,7 +48,7 @@ func ServeCatalog() http.Handler {
if !dbRelease.IsReleased() {
dbRelease.ReleaseType = model.Upcoming
}
release, err := music.GetFullRelease(global.DB, dbRelease)
release, err := music.GetFullRelease(global.DB, dbRelease.ID)
if err != nil {
fmt.Printf("FATAL: Failed to pull full release for %s: %s\n", dbRelease.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)

78
music/view/release.go
View file

@ -12,7 +12,26 @@ import (
"arimelody.me/arimelody.me/templates"
)
// HTTP HANDLERS
type (
Track struct {
Title string `json:"title"`
Description string `json:"description"`
Lyrics string `json:"lyrics"`
}
Credit struct {
*model.Artist
Role string `json:"role"`
Primary bool `json:"primary"`
}
Release struct {
model.Release
Tracks []Track `json:"tracks"`
Credits []Credit `json:"credits"`
Links map[string]string `json:"links"`
}
)
func ServeRelease(release model.Release) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@ -23,22 +42,65 @@ func ServeRelease(release model.Release) http.Handler {
return
}
fullRelease := &model.FullRelease{
Release: &release,
response := Release{
Release: release,
Tracks: []Track{},
Credits: []Credit{},
Links: make(map[string]string),
}
if authorised || release.IsReleased() {
fullerRelease, err := db.GetFullRelease(global.DB, &release)
// get credits
credits, err := db.GetReleaseCredits(global.DB, release.ID)
if err != nil {
fmt.Printf("FATAL: Failed to pull full release data for %s: %s\n", release.ID, err)
fmt.Printf("FATAL: Failed to serve release %s: Credits: %s\n", release.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
fullRelease = fullerRelease
for _, credit := range credits {
artist, err := db.GetArtist(global.DB, credit.Artist.ID)
if err != nil {
fmt.Printf("FATAL: Failed to serve release %s: Artists: %s\n", release.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
response.Credits = append(response.Credits, Credit{
Artist: artist,
Role: credit.Role,
Primary: credit.Primary,
})
}
// get tracks
tracks, err := db.GetReleaseTracks(global.DB, release.ID)
if err != nil {
fmt.Printf("FATAL: Failed to serve release %s: Tracks: %s\n", release.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
for _, track := range tracks {
response.Tracks = append(response.Tracks, Track{
Title: track.Title,
Description: track.Description,
Lyrics: track.Lyrics,
})
}
// get links
links, err := db.GetReleaseLinks(global.DB, release.ID)
if err != nil {
fmt.Printf("FATAL: Failed to serve release %s: Links: %s\n", release.ID, err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
}
for _, link := range links {
response.Links[link.Name] = link.URL
}
}
w.Header().Add("Content-Type", "application/json")
err := json.NewEncoder(w).Encode(fullRelease)
err := json.NewEncoder(w).Encode(response)
if err != nil {
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
return
@ -60,7 +122,7 @@ func ServeGateway(release model.Release) http.Handler {
}
if authorised || release.IsReleased() {
fullerRelease, err := db.GetFullRelease(global.DB, &release)
fullerRelease, err := db.GetFullRelease(global.DB, release.ID)
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)