metadata-agregator/internal/server/mapper.go

package server

import (
	"github.com/metadata-agregator/internal/domain"
	metadatav1 "github.com/metadata-agregator/pkg/gen/metadata/v1"
)

func toProtoArtist(d *domain.Artist) *metadatav1.Artist {
	if d == nil {
		return nil
	}

	a := &metadatav1.Artist{
		Id:          d.ID,
		Name:        d.Name,
		SortName:    d.SortName,
		ArtistType:  d.Type,
		Country:     d.Country,
		Description: d.Description,
		ImageUrl:    d.ImageURL,
	}

	if d.FormedDate != nil {
		a.FormedDate = d.FormedDate.Format("2006-01-02")
	}
	if d.DisbandedDate != nil {
		a.DisbandedDate = d.DisbandedDate.Format("2006-01-02")
	}

	for _, g := range d.Genres {
		a.Genres = append(a.Genres, &metadatav1.Genre{
			Id:   g.ID,
			Name: g.Name,
		})
	}

	for _, e := range d.ExternalIDs {
		a.ExternalIds = append(a.ExternalIds, &metadatav1.ExternalID{
			Source:   e.Source,
			SourceId: e.SourceID,
			Url:      e.URL,
		})
	}

	return a
}

func toProtoAlbum(d *domain.Album) *metadatav1.Album {
	if d == nil {
		return nil
	}

	a := &metadatav1.Album{
		Id:          d.ID,
		Title:       d.Title,
		AlbumType:   d.Type,
		Upc:         d.UPC,
		TotalTracks: int32(d.TotalTracks),
		TotalDiscs:  int32(d.TotalDiscs),
		CoverUrl:    d.CoverURL,
	}

	if d.ReleaseDate != nil {
		a.ReleaseDate = d.ReleaseDate.Format("2006-01-02")
	}

	for _, ac := range d.Artists {
		a.Artists = append(a.Artists, toProtoArtistCredit(&ac))
	}

	if d.Label != nil {
		a.Label = &metadatav1.Label{
			Id:      d.Label.ID,
			Name:    d.Label.Name,
			Country: d.Label.Country,
		}
	}

	for _, g := range d.Genres {
		a.Genres = append(a.Genres, &metadatav1.Genre{
			Id:   g.ID,
			Name: g.Name,
		})
	}

	for _, e := range d.ExternalIDs {
		a.ExternalIds = append(a.ExternalIds, &metadatav1.ExternalID{
			Source:   e.Source,
			SourceId: e.SourceID,
			Url:      e.URL,
		})
	}

	return a
}

func toProtoTrack(d *domain.Track) *metadatav1.Track {
	if d == nil {
		return nil
	}

	t := &metadatav1.Track{
		Id:          d.ID,
		Title:       d.Title,
		DurationMs:  int32(d.DurationMs),
		Isrc:        d.ISRC,
		Explicit:    d.Explicit,
		DiscNumber:  int32(d.DiscNumber),
		TrackNumber: int32(d.TrackNumber),
	}

	for _, ac := range d.Artists {
		t.Artists = append(t.Artists, toProtoArtistCredit(&ac))
	}

	if d.Work != nil {
		t.Work = toProtoWork(d.Work)
	}

	for _, e := range d.ExternalIDs {
		t.ExternalIds = append(t.ExternalIds, &metadatav1.ExternalID{
			Source:   e.Source,
			SourceId: e.SourceID,
			Url:      e.URL,
		})
	}

	return t
}

func toProtoWork(d *domain.Work) *metadatav1.Work {
	if d == nil {
		return nil
	}

	w := &metadatav1.Work{
		Id:       d.ID,
		Title:    d.Title,
		WorkType: d.Type,
		Language: d.Language,
	}

	for _, c := range d.Composers {
		w.Composers = append(w.Composers, toProtoArtistCredit(&c))
	}

	return w
}

func toProtoArtistCredit(d *domain.ArtistCredit) *metadatav1.ArtistCredit {
	if d == nil {
		return nil
	}

	return &metadatav1.ArtistCredit{
		Artist:     toProtoArtist(&d.Artist),
		Role:       d.Role,
		Position:   int32(d.Position),
		JoinPhrase: d.JoinPhrase,
	}
}