ferrispot 0.4.3

A wrapper for the Spotify Web API
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

use log::warn;
use reqwest::{Method, StatusCode};

use super::{request_builder::RequestBuilder, API_USER_PROFILE_ENDPOINT};
#[cfg(feature = "async")]
use crate::client::request_builder::AsyncResponseHandler;
#[cfg(feature = "sync")]
use crate::client::request_builder::SyncResponseHandler;
use crate::{
    client::{
        object,
        request_builder::{BaseRequestBuilderContainer, CatalogItemRequestBuilder, SearchBuilder},
        API_SEARCH_ENDPOINT, API_TRACKS_ENDPOINT,
    },
    error::Error,
    model::{
        id::{Id, IdTrait, TrackId, UserId},
        track::FullTrack,
        user::PublicUser,
    },
};

/// All unscoped Spotify endpoints. The functions in this trait do not require user authentication to use. All Spotify
/// clients implement this trait.
pub trait UnscopedClient
where
    Self: crate::private::Sealed + Clone + Sized,
{
    /// Get Spotify catalog information for a single track identified by its unique Spotify ID.
    ///
    /// An optional market country may be specified with the [`market`-function in the request builder this function
    /// returns](CatalogItemRequestBuilder::market). Only content that is available in that market will be returned and
    /// [track relinking](crate::model::track#track-equality-and-track-relinking) may be applied.
    fn track<'a>(&'a self, track: Id<'a, TrackId>) -> CatalogItemRequestBuilder<Self, FullTrack> {
        let mut builder = CatalogItemRequestBuilder::new(
            Method::GET,
            format!("{}/{}", API_TRACKS_ENDPOINT, track.as_str()),
            self.clone(),
        );

        #[cfg(feature = "async")]
        {
            builder = builder.with_async_response_handler(track_response_handler_async_fn(track.as_owned()));
        }

        #[cfg(feature = "sync")]
        {
            builder = builder.with_sync_response_handler(track_response_handler_sync_fn(track.as_owned()));
        }

        builder
    }

    /// Get Spotify catalog information for multiple tracks based on their Spotify IDs.
    ///
    /// Up to 50 IDs may be given. In case some IDs cannot be found, they will be omitted from the result.
    ///
    /// An optional market country may be specified with the [`market`-function in the request builder this function
    /// returns](CatalogItemRequestBuilder::market). Only content that is available in that market will be returned and
    /// [track relinking](crate::model::track#track-equality-and-track-relinking) may be applied.
    fn tracks<'a, I>(&'a self, tracks: I) -> CatalogItemRequestBuilder<Self, object::TracksResponse, Vec<FullTrack>>
    where
        I: IntoIterator<Item = Id<'a, TrackId>>,
    {
        CatalogItemRequestBuilder::new(Method::GET, API_TRACKS_ENDPOINT, self.clone()).append_query(
            object::TRACKS_IDS_QUERY,
            tracks
                .into_iter()
                .map(|id| id.as_str().to_owned())
                .collect::<Vec<_>>()
                .join(","),
        )
    }

    /// Get Spotify catalog information about albums, artists, playlists, tracks, shows or episodes that match a keyword
    /// string.
    ///
    /// This function returns a [SearchBuilder](self::SearchBuilder) that you can use to configure the various search
    /// parameters and finally send the search query and get the results back.
    fn search<S>(&self, query: S) -> SearchBuilder<Self>
    where
        S: Into<String>,
    {
        SearchBuilder::new(Method::GET, API_SEARCH_ENDPOINT, self.clone()).query(query.into())
    }

    /// Get public information about a Spotify user.
    fn user_profile<'a>(&'a self, user_id: Id<'a, UserId>) -> RequestBuilder<Self, PublicUser> {
        RequestBuilder::new(
            Method::GET,
            format!("{API_USER_PROFILE_ENDPOINT}/{}", user_id.as_str()),
            self.clone(),
        )
    }
}

#[cfg(feature = "async")]
fn track_response_handler_async_fn(track_id: Id<'static, TrackId>) -> AsyncResponseHandler {
    Box::new(move |response| {
        Box::pin(async move {
            match response.status() {
                StatusCode::OK => Ok(response),

                StatusCode::NOT_FOUND => {
                    warn!("Got 404 Not Found to track call");
                    Err(Error::NonexistentTrack(track_id))
                }

                other => Err(Error::UnhandledSpotifyResponseStatusCode(other.as_u16())),
            }
        })
    })
}

#[cfg(feature = "sync")]
fn track_response_handler_sync_fn(track_id: Id<'static, TrackId>) -> SyncResponseHandler {
    Box::new(move |response| match response.status() {
        StatusCode::OK => Ok(response),

        StatusCode::NOT_FOUND => {
            warn!("Got 404 Not Found to track call");
            Err(Error::NonexistentTrack(track_id))
        }

        other => Err(Error::UnhandledSpotifyResponseStatusCode(other.as_u16())),
    })
}