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

use std::borrow::Cow;

use reqwest::Method;

use crate::client::{
    object,
    request_builder::{BaseRequestBuilderContainer, RequestBuilder},
};

/// A base builder type for the various player control request builders.
pub struct BasePlayerControlRequestBuilder<TClient, TBody>(RequestBuilder<TClient, (), TBody>);
/// A builder type for playing a context.
pub struct PlayContextRequestBuilder<TClient>(RequestBuilder<TClient, (), object::PlayContextBody>);

/// A type alias for a builder type for playing one or more playable items.
pub type PlayItemsRequestBuilder<TClient> = BasePlayerControlRequestBuilder<TClient, object::PlayItemsBody>;
/// A type alias for the various player control requests.
pub type PlayerControlRequestBuilder<TClient> = BasePlayerControlRequestBuilder<TClient, ()>;

impl<TClient, TBody> BaseRequestBuilderContainer<TClient, (), TBody>
    for BasePlayerControlRequestBuilder<TClient, TBody>
{
    fn new<S>(method: Method, base_url: S, client: TClient) -> Self
    where
        S: Into<Cow<'static, str>>,
    {
        Self(RequestBuilder::new(method, base_url, client))
    }

    fn new_with_body<S>(method: Method, base_url: S, body: TBody, client: TClient) -> Self
    where
        S: Into<Cow<'static, str>>,
    {
        Self(RequestBuilder::new_with_body(method, base_url, body, client))
    }

    fn take_base_builder(self) -> RequestBuilder<TClient, (), TBody> {
        self.0
    }

    fn get_base_builder_mut(&mut self) -> &mut RequestBuilder<TClient, (), TBody> {
        &mut self.0
    }
}

impl<TClient> BaseRequestBuilderContainer<TClient, (), object::PlayContextBody> for PlayContextRequestBuilder<TClient> {
    fn new<S>(method: Method, base_url: S, client: TClient) -> Self
    where
        S: Into<Cow<'static, str>>,
    {
        Self(RequestBuilder::new(method, base_url, client))
    }

    fn new_with_body<S>(method: Method, base_url: S, body: object::PlayContextBody, client: TClient) -> Self
    where
        S: Into<Cow<'static, str>>,
    {
        Self(RequestBuilder::new_with_body(method, base_url, body, client))
    }

    fn take_base_builder(self) -> RequestBuilder<TClient, (), object::PlayContextBody> {
        self.0
    }

    fn get_base_builder_mut(&mut self) -> &mut RequestBuilder<TClient, (), object::PlayContextBody> {
        &mut self.0
    }
}

impl<TClient, TReturn> BasePlayerControlRequestBuilder<TClient, TReturn> {
    /// Target playback on a certain Spotify device in the user's account.
    pub fn device_id<S>(self, device_id: S) -> Self
    where
        S: Into<Cow<'static, str>>,
    {
        self.append_query(object::DEVICE_ID_QUERY, device_id.into())
    }
}

impl<TClient> PlayContextRequestBuilder<TClient> {
    /// Start playing a certain track from the context, identified by its zero-based index in the context.
    pub fn offset<U>(self, offset: U) -> Self
    where
        U: Into<u32>,
    {
        self.replace_body(|body| object::PlayContextBody {
            offset: object::PlayContextOffset {
                position: Some(offset.into()),
                ..body.offset
            },
            ..body
        })
    }
}