am-api 1.1.0

A library for interfacing with the Apple Music 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

//! Apple music library

use crate::error::Error;
use crate::request::context::ContextContainer;
use crate::request::try_resource_response;
use crate::resource::{Resource, ResourceInfo, ResourceType};
use crate::ApiClient;

use crate::request::builder::MusicRequestBuilder;
use reqwest::header;
use std::collections::{HashMap, HashSet};
use std::sync::Arc;

pub mod album;
pub mod artist;
pub mod music_video;
pub mod playlist;
pub mod song;

/// Library builder
pub struct LibraryBuilder;

/// Library add resource builder
pub type LibraryAddResourceBuilder<'a> =
    MusicRequestBuilder<'a, LibraryBuilder, HashMap<&'static str, HashSet<String>>>;

impl<'a> LibraryAddResourceBuilder<'a> {
    /// Create a new [`LibraryAddResourceBuilder`] instance
    pub fn new() -> LibraryAddResourceBuilder<'a> {
        LibraryAddResourceBuilder::default()
    }

    /// Add a resource to the library
    pub fn add_resource(mut self, resource: &Resource) -> Result<Self, Error> {
        let supported = matches!(
            resource,
            Resource::Album { .. }
                | Resource::Artist { .. }
                | Resource::MusicVideo { .. }
                | Resource::Playlist { .. }
                | Resource::Song { .. }
        );

        if !supported {
            return Err(Error::InvalidResourceType);
        }
        self.data
            .entry(resource.get_type())
            .or_default()
            .insert(resource.get_header().id.clone());

        Ok(self)
    }

    /// Add multiple resources to the library
    pub fn add_resources(mut self, resources: &[Resource]) -> Result<Self, Error> {
        for resource in resources {
            let supported = matches!(
                resource,
                Resource::Album { .. }
                    | Resource::Artist { .. }
                    | Resource::MusicVideo { .. }
                    | Resource::Playlist { .. }
                    | Resource::Song { .. }
            );

            if !supported {
                return Err(Error::InvalidResourceType);
            }
            self.data
                .entry(resource.get_type())
                .or_default()
                .insert(resource.get_header().id.clone());
        }
        Ok(self)
    }

    /// Send the request
    pub async fn send(mut self, client: &ApiClient) -> Result<Vec<Resource>, Error> {
        let mut request_context = self.get_request_context_drain(client);
        request_context
            .query
            .push((String::from("representation"), String::from("ids")));

        for (resource_type, ids) in self.data {
            request_context.query.push((
                format!("ids[{}]", resource_type),
                ids.into_iter().collect::<Vec<_>>().join(","),
            ));
        }

        let request_context = Arc::new(request_context);

        let response = client
            .post("/v1/me/library")
            .header(header::CONTENT_LENGTH, 0)
            .query(&request_context.query)
            .send()
            .await?;

        let mut response = try_resource_response(response).await?;
        response.data.set_context(request_context);
        Ok(response.data)
    }
}