Add missing Track, Album, Artist model types and client methods

Track: Added FileInfo, FileDownloadInfo, TrackFullInfo, SimilarTracks types
Album: Added AlbumSimilarEntities, AlbumTrailer, SimilarEntityItem types
Artist: Added ArtistSimilar, ArtistLinks, ArtistAbout, ArtistInfo, ArtistSkeleton,
       ArtistTrailerStatus, ArtistLink, Stats, SkeletonBlock types

Client methods added:
- artists.go: GetArtistBriefInfo, GetArtistSimilar, GetArtistLinks, GetArtistAlsoAlbums,
  GetArtistDiscographyAlbums, GetArtistSafeDirectAlbums, GetArtistTrackIds, GetArtistAbout,
  GetArtistDonation, GetArtistInfo, GetArtistSkeleton, GetArtistTrailer
- albums.go: GetAlbumSimilarEntities, GetAlbumTrailer
- tracks.go: GetTracksFileInfo, GetTracksSimilar, GetTrackTrailer, GetTrackFullInfo
This commit is contained in:
Mrixs committed 2026-10-18 13:24:41 +03:00
1 parent 9d3bcc4a9b
commit 49920d8908
6 files changed
+783

No files matched your search

+350
View File
@@ -193,12 +193,14 @@ type Cover struct {
// ArtistBriefInfo represents brief artist info.
type ArtistBriefInfo struct {
BaseModel
Description string `json:"description"`
Available bool `json:"available"`
}
// ArtistDonations represents artist donations info.
type ArtistDonations struct {
BaseModel
Items []DonationItem `json:"items"`
Total int `json:"total"`
Goal int `json:"goal"`
@@ -535,3 +537,351 @@ func (c *ClipShort) DeList(data []byte, client ClientInterface) ([]Model, error)
}
return result, nil
}
// ArtistSimilar represents similar artists.
type ArtistSimilar struct {
BaseModel
Artist *Artist `json:"artist"`
SimilarArtists []Artist `json:"similar_artists"`
}
// DeJSON deserializes ArtistSimilar from JSON data.
func (as *ArtistSimilar) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
similar := &ArtistSimilar{BaseModel: *NewBaseModel(c)}
if v, ok := raw["artist"]; ok {
var artist Artist
json.Unmarshal(v, &artist)
similar.Artist = &artist
}
if v, ok := raw["similar_artists"]; ok {
var artists []Artist
json.Unmarshal(v, &artists)
similar.SimilarArtists = artists
}
return similar, nil
}
// DeList deserializes a list of ArtistSimilar from JSON data.
func (as *ArtistSimilar) 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 {
similar := &ArtistSimilar{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, similar); err != nil {
continue
}
result = append(result, similar)
}
return result, nil
}
// ArtistLinks represents links to artist's official pages or social networks.
type ArtistLinks struct {
BaseModel
Links []Link `json:"links"`
}
// DeJSON deserializes ArtistLinks from JSON data.
func (al *ArtistLinks) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
links := &ArtistLinks{BaseModel: *NewBaseModel(c)}
if v, ok := raw["links"]; ok {
var linkList []Link
json.Unmarshal(v, &linkList)
links.Links = linkList
}
return links, nil
}
// DeList deserializes a list of ArtistLinks from JSON data.
func (al *ArtistLinks) 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 {
links := &ArtistLinks{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, links); err != nil {
continue
}
result = append(result, links)
}
return result, nil
}
// ArtistAbout represents information "About artist".
type ArtistAbout struct {
BaseModel
Artist *Artist `json:"artist"`
Stats *Stats `json:"stats"`
Description string `json:"description"`
Links []ArtistLink `json:"links"`
Covers []Cover `json:"covers"`
ArtistType string `json:"artist_type"`
}
// DeJSON deserializes ArtistAbout from JSON data.
func (aa *ArtistAbout) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
about := &ArtistAbout{BaseModel: *NewBaseModel(c)}
if v, ok := raw["artist"]; ok {
var artist Artist
json.Unmarshal(v, &artist)
about.Artist = &artist
}
if v, ok := raw["stats"]; ok {
var stats Stats
json.Unmarshal(v, &stats)
about.Stats = &stats
}
if v, ok := raw["description"]; ok {
json.Unmarshal(v, &about.Description)
}
if v, ok := raw["links"]; ok {
var linkList []ArtistLink
json.Unmarshal(v, &linkList)
about.Links = linkList
}
if v, ok := raw["covers"]; ok {
var covers []Cover
json.Unmarshal(v, &covers)
about.Covers = covers
}
if v, ok := raw["artist_type"]; ok {
json.Unmarshal(v, &about.ArtistType)
}
return about, nil
}
// DeList deserializes a list of ArtistAbout from JSON data.
func (aa *ArtistAbout) 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 {
about := &ArtistAbout{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, about); err != nil {
continue
}
result = append(result, about)
}
return result, nil
}
// ArtistInfo represents detailed artist info.
type ArtistInfo struct {
BaseModel
Artist *Artist `json:"artist"`
LikesCount int `json:"likes_count"`
Stats *Stats `json:"stats"`
Trailer *ArtistTrailerStatus `json:"trailer"`
Covers []Cover `json:"covers"`
Description string `json:"description"`
ArtistType string `json:"artist_type"`
}
// DeJSON deserializes ArtistInfo from JSON data.
func (ai *ArtistInfo) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
info := &ArtistInfo{BaseModel: *NewBaseModel(c)}
if v, ok := raw["artist"]; ok {
var artist Artist
json.Unmarshal(v, &artist)
info.Artist = &artist
}
if v, ok := raw["likes_count"]; ok {
json.Unmarshal(v, &info.LikesCount)
}
if v, ok := raw["stats"]; ok {
var stats Stats
json.Unmarshal(v, &stats)
info.Stats = &stats
}
if v, ok := raw["trailer"]; ok {
var trailer ArtistTrailerStatus
json.Unmarshal(v, &trailer)
info.Trailer = &trailer
}
if v, ok := raw["covers"]; ok {
var covers []Cover
json.Unmarshal(v, &covers)
info.Covers = covers
}
if v, ok := raw["description"]; ok {
json.Unmarshal(v, &info.Description)
}
if v, ok := raw["artist_type"]; ok {
json.Unmarshal(v, &info.ArtistType)
}
return info, nil
}
// DeList deserializes a list of ArtistInfo from JSON data.
func (ai *ArtistInfo) 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 {
info := &ArtistInfo{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, info); err != nil {
continue
}
result = append(result, info)
}
return result, nil
}
// ArtistSkeleton represents artist page skeleton.
type ArtistSkeleton struct {
BaseModel
ID string `json:"id"`
Title string `json:"title"`
Blocks []SkeletonBlock `json:"blocks"`
}
// DeJSON deserializes ArtistSkeleton from JSON data.
func (as *ArtistSkeleton) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
skeleton := &ArtistSkeleton{BaseModel: *NewBaseModel(c)}
if v, ok := raw["id"]; ok {
json.Unmarshal(v, &skeleton.ID)
}
if v, ok := raw["title"]; ok {
json.Unmarshal(v, &skeleton.Title)
}
if v, ok := raw["blocks"]; ok {
var blocks []SkeletonBlock
json.Unmarshal(v, &blocks)
skeleton.Blocks = blocks
}
return skeleton, nil
}
// DeList deserializes a list of ArtistSkeleton from JSON data.
func (as *ArtistSkeleton) 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 {
skeleton := &ArtistSkeleton{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, skeleton); err != nil {
continue
}
result = append(result, skeleton)
}
return result, nil
}
// ArtistTrailerStatus represents trailer availability for artist.
type ArtistTrailerStatus struct {
BaseModel
Available bool `json:"available"`
}
// DeJSON deserializes ArtistTrailerStatus from JSON data.
func (ats *ArtistTrailerStatus) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
status := &ArtistTrailerStatus{BaseModel: *NewBaseModel(c)}
if v, ok := raw["available"]; ok {
json.Unmarshal(v, &status.Available)
}
return status, nil
}
// DeList deserializes a list of ArtistTrailerStatus from JSON data.
func (ats *ArtistTrailerStatus) 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 {
status := &ArtistTrailerStatus{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, status); err != nil {
continue
}
result = append(result, status)
}
return result, nil
}
// ArtistLink represents a link for artist about page.
type ArtistLink struct {
BaseModel
Title string `json:"title"`
Subtitle string `json:"subtitle,omitempty"`
URL string `json:"url,omitempty"`
ImgURL string `json:"img_url,omitempty"`
}
// Stats represents artist stats.
type Stats struct {
BaseModel
Rating int `json:"rating"`
Votes int `json:"votes"`
Month int `json:"month"`
Week int `json:"week"`
Day int `json:"day"`
}
// SkeletonBlock represents a skeleton block.
type SkeletonBlock struct {
BaseModel
ID string `json:"id"`
Type string `json:"type"`
Data json.RawMessage `json:"data"`
}