yandex-music-api-go/internal/models/credits.go

// Package models provides data models for the Yandex Music API.
package models

import (
	"encoding/json"
)

// Credits represents track credits from the Yandex Music API.
type Credits struct {
	BaseModel
	Items []Credit `json:"items"`
	Total int      `json:"total"`
}

// DeJSON deserializes Credits from JSON data.
func (c *Credits) DeJSON(data []byte, client ClientInterface) (Model, error) {
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	credits := &Credits{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["items"]; ok {
		var items []Credit
		json.Unmarshal(v, &items)
		credits.Items = items
	}
	if v, ok := raw["total"]; ok {
		json.Unmarshal(v, &credits.Total)
	}

	return credits, nil
}

// DeList deserializes a list of Credits from JSON data. from JSON data.
func (c *Credits) DeList(data []byte, client ClientInterface) ([]Model, error) {
	var rawList []json.RawMessage
	if err := json.Unmarshal(data, &rawList); err != nil {
		return nil, err
	}

	result := make([]Model, 0, len(rawList))
	for _, item := range rawList {
		credits := &Credits{BaseModel: *NewBaseModel(client)}
		if err := json.Unmarshal(item, credits); err != nil {
			continue
		}
		result = append(result, credits)
	}
	return result, nil
}

// Credit represents a credit.
type Credit struct {
	BaseModel
	Role       string `json:"role"`
	Name       string `json:"name"`
	ArtistID   string `json:"artist_id"`
	ArtistName string `json:"artist_name"`
	IsMain     bool   `json:"is_main"`
	TrackID    string `json:"track_id"`
	AlbumID    string `json:"album_id"`
}

// DeJSON deserializes a Credit from JSON data.
func (c *Credit) DeJSON(data []byte, client ClientInterface) (Model, error) {
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	credit := &Credit{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["role"]; ok {
		json.Unmarshal(v, &credit.Role)
	}
	if v, ok := raw["name"]; ok {
		json.Unmarshal(v, &credit.Name)
	}
	if v, ok := raw["artist_id"]; ok {
		json.Unmarshal(v, &credit.ArtistID)
	}
	if v, ok := raw["artist_name"]; ok {
		json.Unmarshal(v, &credit.ArtistName)
	}
	if v, ok := raw["is_main"]; ok {
		json.Unmarshal(v, &credit.IsMain)
	}
	if v, ok := raw["track_id"]; ok {
		json.Unmarshal(v, &credit.TrackID)
	}
	if v, ok := raw["album_id"]; ok {
		json.Unmarshal(v, &credit.AlbumID)
	}

	return credit, nil
}

// DeList deserializes a list of Credits
func (c *Credit) DeList(data []byte, client ClientInterface) ([]Model, error) {
	var rawList []json.RawMessage
	if err := json.Unmarshal(data, &rawList); err != nil {
		return nil, err
	}

	result := make([]Model, 0, len(rawList))
	for _, item := range rawList {
		credit := &Credit{BaseModel: *NewBaseModel(client)}
		if err := json.Unmarshal(item, credit); err != nil {
			continue
		}
		result = append(result, credit)
	}
	return result, nil
}

// LicenceTextPart represents a licence text part.
type LicenceTextPart struct {
	BaseModel
	Text     string `json:"text"`
	Language string `json:"language"`
	URL      string `json:"url"`
	Title    string `json:"title"`
	IsMain   bool   `json:"is_main"`
}

// DeJSON deserializes a LicenceTextPart from JSON data.
func (ltp *LicenceTextPart) DeJSON(data []byte, client ClientInterface) (Model, error) {
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	part := &LicenceTextPart{BaseModel: *NewBaseModel(client)}

	if v, ok := raw["text"]; ok {
		json.Unmarshal(v, &part.Text)
	}
	if v, ok := raw["language"]; ok {
		json.Unmarshal(v, &part.Language)
	}
	if v, ok := raw["url"]; ok {
		json.Unmarshal(v, &part.URL)
	}
	if v, ok := raw["title"]; ok {
		json.Unmarshal(v, &part.Title)
	}
	if v, ok := raw["is_main"]; ok {
		json.Unmarshal(v, &part.IsMain)
	}

	return part, nil
}

// DeList deserializes a list of LicenceTextPart from JSON data.
func (ltp *LicenceTextPart) DeList(data []byte, client ClientInterface) ([]Model, error) {
	var rawList []json.RawMessage
	if err := json.Unmarshal(data, &rawList); err != nil {
		return nil, err
	}

	result := make([]Model, 0, len(rawList))
	for _, item := range rawList {
		part := &LicenceTextPart{BaseModel: *NewBaseModel(client)}
		if err := json.Unmarshal(item, part); err != nil {
			continue
		}
		result = append(result, part)
	}
	return result, nil
}

// Disclaimer represents a disclaimer.
type Disclaimer struct {
	BaseModel
	ForeignAgent *ForeignAgent `json:"foreign_agent"`
}

// DeJSON deserializes Disclaimer from JSON data.
func (d *Disclaimer) DeJSON(data []byte, c ClientInterface) (Model, error) {
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	disclaimer := &Disclaimer{BaseModel: *NewBaseModel(c)}

	if v, ok := raw["foreign_agent"]; ok {
		var fa ForeignAgent
		json.Unmarshal(v, &fa)
		disclaimer.ForeignAgent = &fa
	}

	return disclaimer, nil
}

// DeList deserializes a list of Disclaimers from JSON data.
func (d *Disclaimer) DeList(data []byte, c ClientInterface) ([]Model, error) {
	var rawList []json.RawMessage
	if err := json.Unmarshal(data, &rawList); err != nil {
		return nil, err
	}

	result := make([]Model, 0, len(rawList))
	for _, item := range rawList {
		disclaimer := &Disclaimer{BaseModel: *NewBaseModel(c)}
		if err := json.Unmarshal(item, disclaimer); err != nil {
			continue
		}
		result = append(result, disclaimer)
	}
	return result, nil
}

// ForeignAgent represents a foreign agent.
type ForeignAgent struct {
	BaseModel
	Text string `json:"text"`
}

// DeJSON deserializes ForeignAgent from JSON data.
func (fa *ForeignAgent) DeJSON(data []byte, c ClientInterface) (Model, error) {
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, err
	}

	agent := &ForeignAgent{BaseModel: *NewBaseModel(c)}

	if v, ok := raw["text"]; ok {
		json.Unmarshal(v, &agent.Text)
	}

	return agent, nil
}

// DeList deserializes a list of ForeignAgent from JSON data.
func (fa *ForeignAgent) DeList(data []byte, c ClientInterface) ([]Model, error) {
	var rawList []json.RawMessage
	if err := json.Unmarshal(data, &rawList); err != nil {
		return nil, err
	}

	result := make([]Model, 0, len(rawList))
	for _, item := range rawList {
		agent := &ForeignAgent{BaseModel: *NewBaseModel(c)}
		if err := json.Unmarshal(item, agent); err != nil {
			continue
		}
		result = append(result, agent)
	}
	return result, nil
}