Add remaining model types and client methods

Models added:
- Disclaimer, ForeignAgent (credits.go)
- ArtistConcerts (concert.go)
- Dashboard, StationResult, Station, AdParams, GenerativeStream,
  GenerativeStreamData, GenerativeStreamInfo (radio.go)
- FileInfo, FileDownloadInfo, TrackFullInfo, SimilarTracks, TrackTrailer (track.go)
- Removed duplicate AdParams from feed.go

Client methods added:
- artists.go: GetArtistBriefInfo, GetArtistSimilar, GetArtistLinks,
  GetArtistAlsoAlbums, GetArtistDiscographyAlbums, GetArtistSafeDirectAlbums,
  GetArtistTrackIds, GetArtistAbout, GetArtistDonation, GetArtistInfo,
  GetArtistSkeleton, GetArtistTrailer
- albums.go: GetAlbumSimilarEntities, GetAlbumTrailer
- clips.go: GetClipsDisclaimer
- concerts.go: GetArtistConcerts, GetConcertSkeleton
- radio.go: GetRotorStationsDashboard, GetRotorStationsList,
  GetRotorStationInfo, GetRotorStationStream, GetRotorStationSettings
- supplements.go: GetTracksCredits, GetClipsCredits
- queue.go: GetQueuesList
- tracks.go: GetTracksFileInfo, GetTracksSimilar, GetTrackTrailer, GetTrackFullInfo
This commit is contained in:
Mrixs committed 2026-10-18 13:32:45 +03:00
1 parent 49920d8908
commit 73775a8526
9 files changed
+639 -7

No files matched your search

+388
View File
@@ -317,6 +317,70 @@ func (r *RotorSession) DeList(data []byte, client ClientInterface) ([]Model, err
return result, nil
}
// AdParams represents ad parameters.
type AdParams struct {
BaseModel
PartnerID string `json:"partner_id"`
CategoryID string `json:"category_id"`
PageRef string `json:"page_ref"`
TargetRef string `json:"target_ref"`
OtherParams string `json:"other_params"`
GenreID string `json:"genre_id"`
GenreName string `json:"genre_name"`
}
// DeJSON deserializes AdParams from JSON data.
func (ap *AdParams) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
params := &AdParams{BaseModel: *NewBaseModel(c)}
if v, ok := raw["partner_id"]; ok {
json.Unmarshal(v, &params.PartnerID)
}
if v, ok := raw["category_id"]; ok {
json.Unmarshal(v, &params.CategoryID)
}
if v, ok := raw["page_ref"]; ok {
json.Unmarshal(v, &params.PageRef)
}
if v, ok := raw["target_ref"]; ok {
json.Unmarshal(v, &params.TargetRef)
}
if v, ok := raw["other_params"]; ok {
json.Unmarshal(v, &params.OtherParams)
}
if v, ok := raw["genre_id"]; ok {
json.Unmarshal(v, &params.GenreID)
}
if v, ok := raw["genre_name"]; ok {
json.Unmarshal(v, &params.GenreName)
}
return params, nil
}
// DeList deserializes a list of AdParams from JSON data.
func (ap *AdParams) 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 {
params := &AdParams{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, params); err != nil {
continue
}
result = append(result, params)
}
return result, nil
}
// SessionFeedback represents session feedback.
type SessionFeedback struct {
BaseModel
@@ -330,3 +394,327 @@ type SessionFeedbacks struct {
BaseModel
Feedbacks []SessionFeedback `json:"feedbacks"`
}
// Dashboard represents rotor stations dashboard.
type Dashboard struct {
BaseModel
DashboardID string `json:"dashboard_id"`
Stations []StationResult `json:"stations"`
Pumpkin bool `json:"pumpkin"`
}
// DeJSON deserializes Dashboard from JSON data.
func (d *Dashboard) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
dashboard := &Dashboard{BaseModel: *NewBaseModel(c)}
if v, ok := raw["dashboard_id"]; ok {
json.Unmarshal(v, &dashboard.DashboardID)
}
if v, ok := raw["stations"]; ok {
var stations []StationResult
json.Unmarshal(v, &stations)
dashboard.Stations = stations
}
if v, ok := raw["pumpkin"]; ok {
json.Unmarshal(v, &dashboard.Pumpkin)
}
return dashboard, nil
}
// DeList deserializes a list of Dashboards from JSON data.
func (d *Dashboard) 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 {
dashboard := &Dashboard{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, dashboard); err != nil {
continue
}
result = append(result, dashboard)
}
return result, nil
}
// StationResult represents a station result.
type StationResult struct {
BaseModel
Station *Station `json:"station"`
Settings *RotorSettings `json:"settings"`
Settings2 *RotorSettings `json:"settings2"`
AdParams *AdParams `json:"ad_params"`
}
// DeJSON deserializes StationResult from JSON data.
func (sr *StationResult) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
result := &StationResult{BaseModel: *NewBaseModel(c)}
if v, ok := raw["station"]; ok {
var station Station
json.Unmarshal(v, &station)
result.Station = &station
}
if v, ok := raw["settings"]; ok {
var settings RotorSettings
json.Unmarshal(v, &settings)
result.Settings = &settings
}
if v, ok := raw["settings2"]; ok {
var settings2 RotorSettings
json.Unmarshal(v, &settings2)
result.Settings2 = &settings2
}
if v, ok := raw["ad_params"]; ok {
var adParams AdParams
json.Unmarshal(v, &adParams)
result.AdParams = &adParams
}
return result, nil
}
// DeList deserializes a list of StationResults from JSON data.
func (sr *StationResult) 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 {
sr := &StationResult{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, sr); err != nil {
continue
}
result = append(result, sr)
}
return result, nil
}
// GenerativeStream represents a generative stream.
type GenerativeStream struct {
BaseModel
Data *GenerativeStreamData `json:"data"`
Version string `json:"version"`
Stream *GenerativeStreamInfo `json:"stream"`
}
// DeJSON deserializes GenerativeStream from JSON data.
func (gs *GenerativeStream) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
stream := &GenerativeStream{BaseModel: *NewBaseModel(c)}
if v, ok := raw["data"]; ok {
var data GenerativeStreamData
json.Unmarshal(v, &data)
stream.Data = &data
}
if v, ok := raw["version"]; ok {
json.Unmarshal(v, &stream.Version)
}
if v, ok := raw["stream"]; ok {
var streamInfo GenerativeStreamInfo
json.Unmarshal(v, &streamInfo)
stream.Stream = &streamInfo
}
return stream, nil
}
// DeList deserializes a list of GenerativeStreams from JSON data.
func (gs *GenerativeStream) 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 {
stream := &GenerativeStream{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, stream); err != nil {
continue
}
result = append(result, stream)
}
return result, nil
}
// Station represents a radio station (used in StationResult).
type Station struct {
BaseModel
ID JSONID `json:"id"`
Name string `json:"name"`
Icon string `json:"icon"`
IDForFrom string `json:"id_for_from"`
}
// DeJSON deserializes Station from JSON data.
func (s *Station) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
station := &Station{BaseModel: *NewBaseModel(c)}
if v, ok := raw["id"]; ok {
json.Unmarshal(v, &station.ID)
}
if v, ok := raw["name"]; ok {
json.Unmarshal(v, &station.Name)
}
if v, ok := raw["icon"]; ok {
json.Unmarshal(v, &station.Icon)
}
if v, ok := raw["id_for_from"]; ok {
json.Unmarshal(v, &station.IDForFrom)
}
return station, nil
}
// DeList deserializes a list of Stations from JSON data.
func (s *Station) 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 {
station := &Station{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, station); err != nil {
continue
}
result = append(result, station)
}
return result, nil
}
// GenerativeStreamData represents generative stream data.
type GenerativeStreamData struct {
BaseModel
Title string `json:"title"`
Subtitle string `json:"subtitle"`
BackgroundColor string `json:"background_color"`
DerivedColors *CoverDerivedColors `json:"derived_colors"`
ImageURL string `json:"image_url"`
VideoCoverURI string `json:"video_cover_uri"`
Explanations string `json:"explanations"`
}
// DeJSON deserializes GenerativeStreamData from JSON data.
func (gsd *GenerativeStreamData) DeJSON(data []byte, c ClientInterface) (Model, error) {
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return nil, err
}
gsdData := &GenerativeStreamData{BaseModel: *NewBaseModel(c)}
if v, ok := raw["title"]; ok {
json.Unmarshal(v, &gsdData.Title)
}
if v, ok := raw["subtitle"]; ok {
json.Unmarshal(v, &gsdData.Subtitle)
}
if v, ok := raw["background_color"]; ok {
json.Unmarshal(v, &gsdData.BackgroundColor)
}
if v, ok := raw["derived_colors"]; ok {
var dc CoverDerivedColors
json.Unmarshal(v, &dc)
gsdData.DerivedColors = &dc
}
if v, ok := raw["image_url"]; ok {
json.Unmarshal(v, &gsdData.ImageURL)
}
if v, ok := raw["video_cover_uri"]; ok {
json.Unmarshal(v, &gsdData.VideoCoverURI)
}
if v, ok := raw["explanations"]; ok {
json.Unmarshal(v, &gsdData.Explanations)
}
return gsdData, nil
}
// DeList deserializes a list of GenerativeStreamData from JSON data.
func (gsd *GenerativeStreamData) 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 {
data := &GenerativeStreamData{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, data); err != nil {
continue
}
result = append(result, data)
}
return result, nil
}
// GenerativeStreamInfo represents generative stream info.
type GenerativeStreamInfo struct {
BaseModel
ID string `json:"id"`
URL string `json:"url"`
}
// DeJSON deserializes GenerativeStreamInfo from JSON data.
func (gsi *GenerativeStreamInfo) 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 := &GenerativeStreamInfo{BaseModel: *NewBaseModel(c)}
if v, ok := raw["id"]; ok {
json.Unmarshal(v, &info.ID)
}
if v, ok := raw["url"]; ok {
json.Unmarshal(v, &info.URL)
}
return info, nil
}
// DeList deserializes a list of GenerativeStreamInfo from JSON data.
func (gsi *GenerativeStreamInfo) 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 := &GenerativeStreamInfo{BaseModel: *NewBaseModel(c)}
if err := json.Unmarshal(item, info); err != nil {
continue
}
result = append(result, info)
}
return result, nil
}