arimelody-web/repository/music/release_memory.go

package music

import (
	"arimelody-web/errors"
	"arimelody-web/model"
	"fmt"
	"slices"
	"time"
)

func (repo *MusicRepositoryMemory) GetAllReleases(onlyVisible bool, limit int) ([]*model.Release, error) {
    releases := []*model.Release{}
    for _, release := range repo.releases {
        if !onlyVisible || release.Visible {
            releases = append(releases, release)
        }
    }
    return releases, nil
}
func (repo *MusicRepositoryMemory) GetReleaseCount(onlyVisible bool) (int, error) {
    releaseCount := 0
    for _, release := range repo.releases {
        if !onlyVisible || release.Visible {
            releaseCount++
        }
    }
    return releaseCount, nil
}

func (repo *MusicRepositoryMemory) GetReleaseByID(id string) (*model.Release, error) {
    index := slices.IndexFunc(repo.releases, func(release *model.Release) bool {
        return release.ID == id
    })
    if index == -1 { return nil, nil }
    return repo.releases[index], nil
}

func (repo *MusicRepositoryMemory) GetReleaseTracks(id string) ([]*model.Track, error) {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return nil, err }
    return release.Tracks, nil
}

func (repo *MusicRepositoryMemory) GetReleaseCredits(id string) ([]*model.Credit, error) {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return nil, err }
    return release.Credits, nil
}

func (repo *MusicRepositoryMemory) GetReleaseLinks(id string) ([]*model.Link, error) {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return nil, err }
    return release.Links, nil
}

func (repo *MusicRepositoryMemory) CreateRelease(
    id string,
    title string,
    releaseType model.ReleaseType,
    releaseDate time.Time,
    artworkURL string,
) error {
    if release, err := repo.GetReleaseByID(id); err != nil {
        if !errors.IsNotExistError(err) { return err }
    } else {
        if release != nil { return errors.NewValidationError("Release with this ID already exists") }
    }

    repo.releases = append(repo.releases, &model.Release{
        ID: id,
        Title: title,
        ReleaseType: releaseType,
        ReleaseDate: releaseDate,
        Artwork: artworkURL,
    })
    return nil
}

func (repo *MusicRepositoryMemory) UpdateRelease(release *model.Release) error {
    repoRelease, err := repo.GetReleaseByID(release.ID)
    if err != nil { return err }
    if repoRelease == nil { return errors.NewNotExistError("Release does not exist") }

    repoRelease.Visible = release.Visible
    repoRelease.Title = release.Title
    repoRelease.Description = release.Description
    repoRelease.ReleaseType = release.ReleaseType
    repoRelease.ReleaseDate = release.ReleaseDate
    repoRelease.Artwork = release.Artwork
    repoRelease.Buyname = release.Buyname
    repoRelease.Buylink = release.Buylink
    repoRelease.Copyright = release.Copyright
    repoRelease.CopyrightURL = release.CopyrightURL

    return nil
}

func (repo *MusicRepositoryMemory) UpdateReleaseID(oldID string, newID string) error {
    release, err := repo.GetReleaseByID(oldID)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }
    release.ID = newID
    return nil
}
func (repo *MusicRepositoryMemory) UpdateReleaseVisibility(id string, visible bool) error {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }
    release.Visible = visible
    return nil
}
func (repo *MusicRepositoryMemory) UpdateReleaseTitle(id string, title string) error {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }
    release.Title = title
    return nil
}
func (repo *MusicRepositoryMemory) UpdateReleaseDescription(id string, description string) error {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }
    release.Description = description
    return nil
}
func (repo *MusicRepositoryMemory) UpdateReleaseType(id string, releaseType model.ReleaseType) error {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }
    release.ReleaseType = releaseType
    return nil
}
func (repo *MusicRepositoryMemory) UpdateReleaseDate(id string, releaseDate time.Time) error {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }
    release.ReleaseDate = releaseDate
    return nil
}
func (repo *MusicRepositoryMemory) UpdateReleaseArtwork(id string, artwork string) error {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }
    release.Artwork = artwork
    return nil
}
func (repo *MusicRepositoryMemory) UpdateReleaseBuyInfo(id string, buyName string, buyLink string) error {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }
    release.Buyname = buyName
    release.Buylink = buyLink
    return nil
}
func (repo *MusicRepositoryMemory) UpdateReleaseCopyright(id string, copyright string, url string) error {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }
    release.Copyright = copyright
    release.CopyrightURL = url
    return nil
}

func (repo *MusicRepositoryMemory) UpdateReleaseTracks(id string, newTrackIDs []string) error {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }

    tracks := []*model.Track{}
    for _, trackID := range newTrackIDs {
        track, err := repo.GetTrackByID(trackID)
        if err != nil {
            if errors.IsNotExistError(err) {
                return errors.NewNotExistError(fmt.Sprintf("Track %s does not exist", trackID))
            }
            return err
        }
        tracks = append(tracks, track)
    }
    release.Tracks = tracks

    return nil
}

func (repo *MusicRepositoryMemory) UpdateReleaseCredits(id string, newCredits []*model.Credit) error {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }

    for _, credit := range newCredits {
        if credit.Artist == nil { return errors.NewValidationError("Credit artist cannot be empty") }
        if len(credit.Artist.ID) == 0 { return errors.NewValidationError("Credit artist ID cannot be empty") }
        if artist, err := repo.GetArtistByID(credit.Artist.ID); err != nil {
            return err
        } else if artist == nil {
            return errors.NewNotExistError(fmt.Sprintf("Artist '%s' does not exist", credit.Artist.ID))
        } else {
            credit.Release = release
            credit.Artist = artist
        }
    }

    release.Credits = newCredits

    return nil
}

func (repo *MusicRepositoryMemory) UpdateReleaseLinks(id string, newLinks []*model.Link) error {
    release, err := repo.GetReleaseByID(id)
    if err != nil { return err }
    if release == nil { return errors.NewNotExistError("Release does not exist") }
    release.Links = newLinks
    return nil
}

func (repo *MusicRepositoryMemory) DeleteRelease(id string) (string, error) {
    var deletedID string
    newReleases := []*model.Release{}
    for _, release := range repo.releases {
        if release.ID == id {
            deletedID = id
            continue
        }
        newReleases = append(newReleases, release)
    }
    repo.releases = newReleases
    return deletedID, nil
}