arimelody.me/music/controller/release.go

package music

import (
	"errors"
	"fmt"

	"arimelody.me/arimelody.me/music/model"
	"github.com/jmoiron/sqlx"
)

func GetRelease(db *sqlx.DB, id string) (*model.Release, error) {
    var releases = model.Release{}

    err := db.Get(&releases, "SELECT * FROM musicrelease WHERE id=$1", id)
    if err != nil {
        return nil, err
    }

    return &releases, nil
}

func GetAllReleases(db *sqlx.DB) ([]*model.Release, error) {
    var releases = []*model.Release{}

    err := db.Select(&releases, "SELECT * FROM musicrelease ORDER BY release_date DESC")
    if err != nil {
        return nil, err
    }

    return releases, 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, copyright, copyrighturl) "+
        "VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)",
        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,
        release.Copyright,
        release.CopyrightURL,
    )
    if err != nil {
        return err
    }

    return nil
}

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, copyright=$10, copyrighturl=$11 "+
        "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,
        release.Copyright,
        release.CopyrightURL,
    )
    if err != nil {
        return err
    }

    return nil
}

func UpdateReleaseTracks(db *sqlx.DB, release *model.Release, new_tracks []string) error {
    _, err := db.Exec(
        "DELETE FROM musicreleasetrack "+
        "WHERE release=$1",
        release.ID,
    )
    if err != nil {
        return err
    }

    for i, trackID := range new_tracks {
        _, err = db.Exec(
            "INSERT INTO musicreleasetrack "+
            "(release, track, number) "+
            "VALUES ($1, $2, $3)",
            release.ID,
            trackID,
            i,
        )
        if err != nil {
            return err
        }
    }

    return nil
}

func UpdateReleaseCredits(db *sqlx.DB, release *model.Release, new_credits []model.Credit) error {
    _, err := db.Exec(
        "DELETE FROM musiccredit "+
        "WHERE release=$1",
        release.ID,
    )
    if err != nil {
        return err
    }

    for _, credit := range new_credits {
        _, err = db.Exec(
            "INSERT INTO musiccredit "+
            "(release, artist, role, is_primary) "+
            "VALUES ($1, $2, $3, $4)",
            release.ID,
            credit.Artist.ID,
            credit.Role,
            credit.Primary,
        )
        if err != nil {
            return err
        }
    }

    return nil
}

func UpdateReleaseLinks(db *sqlx.DB, release *model.Release, new_links []*model.Link) error {
    _, err := db.Exec(
        "DELETE FROM musiclink "+
        "WHERE release=$1",
        release.ID,
    )
    if err != nil {
        return err
    }

    for _, link := range new_links {
        _, err = db.Exec(
            "INSERT INTO musiclink "+
            "(release, name, url) "+
            "VALUES ($1, $2, $3)",
            release.ID,
            link.Name,
            link.URL,
        )
        if err != nil {
            return err
        }
    }

    return nil
}

func DeleteRelease(db *sqlx.DB, release *model.Release) error {
    _, err := db.Exec(
        "DELETE FROM musicrelease "+
        "WHERE id=$1",
        release.ID,
    )
    if err != nil {
        return err
    }

    return nil
}

func GetFullRelease(db *sqlx.DB, releaseID string) (*model.FullRelease, error) {
    // get release
    release, err := GetRelease(db, releaseID)
    if err != nil {
        return nil, err
    }

    // get credits
    credits, err := GetReleaseCredits(db, releaseID)
    if err != nil {
        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 {
        tracks = append(tracks, track.MakeDisplay(i + 1))
    }

    // get links
    links, err := GetReleaseLinks(db, releaseID)
    if err != nil {
        return nil, errors.New(fmt.Sprintf("Links: %s", err))
    }

    return &model.FullRelease{
        Release: release,
        Tracks: tracks,
        Credits: credits,
        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
}