rust_fm 0.1.4

last.fm OAUTH and scrobbling
Documentation 
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

use reqwest::ClientBuilder;
use chrono::Utc;
use chrono::DateTime;

use crate::auth::WebOAuth;
use crate::auth::Signature;

#[derive(Clone, Debug)]
/// A scrobble object.
pub struct Scrobble {
    title: String,
    artist: String,
    album: Option<String>
}

impl Scrobble {
    pub fn new(title: String, artist: String, album: Option<String>) -> Self {
        Self { title, artist, album }
    }
}

#[derive(Clone, Debug)]
pub enum ScrobbleError {
    MissingFields,
    ClientFailed,
    ResponseError,
    TextError
}

pub struct NowPlaying;
impl NowPlaying {
    /// Set the 'now playing' status. This does not have any rules.
    /// Requires the auth to contain a valid key, session and token.
    pub async fn set_now_playing(auth: WebOAuth, scrobble: Scrobble) -> Result<(), ScrobbleError> {
        let (key, session, secret) = match (auth.get_key(), auth.get_session(), auth.get_secret()) {
            (Some(key), Some(token), Some(secret)) => (key, token, secret),
            _ => return Err(ScrobbleError::MissingFields)
        };

        let mut buffer = String::new();

        let mut args_vec = vec![
            ("api_key", key),
            ("artist", scrobble.artist.as_str()),
            ("method", "track.updatenowplaying"),
            ("sk", session),
            ("track", scrobble.title.as_str())
        ];

        if let Some(album) = scrobble.album.as_ref() {
            args_vec.push(("album", album.as_str()));
        }

        let args = Signature::from_args(args_vec, &mut buffer, secret);

        let client = match ClientBuilder::new().build() {
            Ok(client) => client,
            Err(_) => return Err(ScrobbleError::ClientFailed)
        };

        let response = match client
            .post(crate::api::URL)
            .form(&args)
            .send()
            .await {
            Ok(response) => response,
            Err(_) => return Err(ScrobbleError::ResponseError)
        };

        let text = match response.text().await {
            Ok(text) => text,
            Err(_) => return Err(ScrobbleError::TextError)
        };

        println!("{text}");

        Ok(())
    }

    /// Push an actual scrobble. Refer to last.fm's API documentation to see the rules here.
    /// This function does not abide by any rules, and will generate a timestamp if none is provided.
    pub async fn push_scrobble(
        auth: WebOAuth, scrobble: Scrobble, start_time: Option<DateTime<Utc>>
    ) -> Result<(), ScrobbleError> {

        let utc = match start_time {
            Some(start_time) => start_time,
            None => Utc::now()
        };

        let (key, session, secret) = match (auth.get_key(), auth.get_session(), auth.get_secret()) {
            (Some(key), Some(token), Some(secret)) => (key, token, secret),
            _ => return Err(ScrobbleError::MissingFields)
        };

        let mut buffer = String::new();
        let timestamp = utc.timestamp().to_string();

        let mut args_vec = vec![
            ("api_key", key),
            ("artist[0]", scrobble.artist.as_str()),
            ("method", "track.scrobble"),
            ("sk", session),
            ("track[0]", scrobble.title.as_str()),
            ("timestamp[0]", timestamp.as_str())
        ];

        if let Some(album) = scrobble.album.as_ref() {
            args_vec.push(("album[0]", album.as_str()));
        }

        let args = Signature::from_args(args_vec, &mut buffer, secret);

        let client = match ClientBuilder::new().build() {
            Ok(client) => client,
            Err(_) => return Err(ScrobbleError::ClientFailed)
        };

        let response = match client
            .post(crate::api::URL)
            .form(&args)
            .send()
            .await {
            Ok(response) => response,
            Err(_) => return Err(ScrobbleError::ResponseError)
        };

        let text = match response.text().await {
            Ok(text) => text,
            Err(_) => return Err(ScrobbleError::TextError)
        };

        println!("{text}");

        Ok(())
    }
}