pandora 0.1.1

Unofficial Rust library for interacting with the Pandora API
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Playlists for a [Station](stations/struct.Stations.html).

use super::Pandora;
use error::Result;
use method::Method;
use stations::ToStationToken;

use serde_json;

/// Handler for Playlists.
#[derive(Debug)]
pub struct Playlist<'a> {
    pandora: &'a Pandora,
    station_token: String,
}

impl<'a> Playlist<'a> {
    /// Creates a new Playlist handler.
    pub fn new<T>(pandora: &'a Pandora, station: &T) -> Playlist<'a>
    where T: ToStationToken {
        Playlist { pandora: pandora, station_token: station.to_station_token() }
    }

    /// Gets the current tracklist from Pandora.
    pub fn list(&self) -> Result<Vec<Track>> {
        let tracklist = try!(self.pandora.post::<Tracklist>(
            Method::StationGetPlaylist,
            Some(serde_json::to_value(TracklistRequest {
                station_token: self.station_token.clone()
            }))
        ));
        Ok(tracklist.items)
    }

    // TODO: Result should not be empty
    /// Rates a track.
    pub fn rate<T>(&self, track: T, is_positive: bool) -> Result<()>
    where T: ToTrackToken {
        self.pandora.post_noop(
            Method::StationAddFeedback,
            Some(serde_json::to_value(RateTrackRequest {
                station_token: self.station_token.clone(),
                track_token: track.to_track_token().unwrap_or("".to_owned()),
                is_positive: is_positive,
            }))
        )
    }
}

/// Trait for types that return a track token.
pub trait ToTrackToken {
    fn to_track_token(&self) -> Option<String>;
}

/// List of tracks.
#[derive(Debug, Deserialize)]
struct Tracklist {
    pub items: Vec<Track>,
}

/// Track information. Most fields are optional since
/// the tracklist can include ads.
#[derive(Debug, Clone, Deserialize)]
pub struct Track {
    #[serde(rename="trackToken")]
    pub track_token: Option<String>,
    #[serde(rename="artistName")]
    pub artist_name: Option<String>,
    #[serde(rename="albumName")]
    pub album_name: Option<String>,
    #[serde(rename="songName")]
    pub song_name: Option<String>,
    #[serde(rename="songRating")]
    pub song_rating: Option<u32>,

    #[serde(rename="audioUrlMap")]
    pub track_audio: Option<TrackAudio>,

    #[serde(rename="adToken")]
    pub ad_token: Option<String>,
}

impl Track {
    pub fn is_ad(&self) -> bool {
        self.ad_token.is_some()
    }
}

impl ToTrackToken for Track {
    fn to_track_token(&self) -> Option<String> {
        match self.track_token {
            Some(ref track_token) => Some(track_token.clone()),
            None => None
        }
    }
}

impl<'a> ToTrackToken for &'a Track {
    fn to_track_token(&self) -> Option<String> {
        match self.track_token {
            Some(ref track_token) => Some(track_token.clone()),
            None => None
        }
    }
}

/// Struct for deserializing audio types for a track.
#[derive(Debug, Clone, Deserialize)]
pub struct TrackAudio {
    #[serde(rename="lowQuality")]
    pub low_quality: Audio,
    #[serde(rename="mediumQuality")]
    pub medium_quality: Audio,
    #[serde(rename="highQuality")]
    pub high_quality: Audio,
}

/// Audio information for a track.
#[derive(Debug, Clone, Deserialize)]
pub struct Audio {
    pub bitrate: String,
    pub encoding: String,
    #[serde(rename="audioUrl")]
    pub audio_url: String,
    pub protocol: String,
}

////////////////////
// Request structs
////////////////////

#[derive(Serialize)]
struct TracklistRequest {
    #[serde(rename="stationToken")]
    station_token: String,
}

#[derive(Serialize)]
struct RateTrackRequest {
    #[serde(rename="stationToken")]
    station_token: String,
    #[serde(rename="trackToken")]
    track_token: String,
    #[serde(rename="isPositive")]
    is_positive: bool,
}