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
|
use lazy_static::lazy_static;
use rocket::http::Status;
use rocket::response::{status, Redirect};
use rspotify::spotify::client::{ApiError, Spotify};
use rspotify::spotify::oauth2::{SpotifyClientCredentials, SpotifyOAuth};
use rspotify::spotify::util::process_token;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
lazy_static! {
static ref CACHE: Arc<Mutex<HashMap<String, SpotifyOAuth>>> =
Arc::new(Mutex::new(HashMap::new()));
}
#[get("/callback/<name>/<url>")]
pub fn get_tracks(name: String, url: String) -> String {
let mut guard = CACHE.lock().unwrap();
let mut oauth = guard.remove(&name).unwrap();
println!("auth: {:?} url: {}", oauth, url);
let token_info = process_token(&mut oauth, &mut ("?code=".to_owned() + url.as_ref()));
let client_credential = SpotifyClientCredentials::default()
.token_info(token_info.unwrap())
.build();
let spotify = Spotify::default()
.client_credentials_manager(client_credential)
.build();
let user_id = spotify.current_user().unwrap().id;
let chunk_size = 50;
let mut playlist_index = 0;
loop {
match spotify.user_playlists(user_id.as_ref(), Some(chunk_size), Some(playlist_index)) {
Ok(playlists) => {
playlist_index += chunk_size;
if playlists.items.is_empty() {
break;
}
for playlist in playlists.items {
println!("playlist: {:?}", playlist.name);
let mut track_index = 0;
loop {
match spotify.user_playlist_tracks(
user_id.as_ref(),
&playlist.id,
None,
Some(chunk_size),
Some(track_index),
None,
) {
Ok(tracks) => {
track_index += chunk_size;
if tracks.items.is_empty() {
break;
}
for track in tracks.items {
println!("{:?}", track.track.name);
}
}
Err(e) => match e.downcast::<ApiError>() {
Ok(ApiError::RateLimited(x)) => std::thread::sleep(
std::time::Duration::from_secs(x.unwrap_or(5) as u64),
),
cause => {
println!("Error: {:?}", cause);
break;
}
},
}
}
}
}
Err(e) => match e.downcast::<ApiError>() {
Ok(ApiError::RateLimited(x)) => {
std::thread::sleep(std::time::Duration::from_secs(x.unwrap_or(5) as u64))
}
cause => {
println!("Error: {:?}", cause);
break;
}
},
}
}
name
}
#[get("/token/<name>")]
pub fn token(name: String) -> Result<Redirect, status::Custom<String>> {
let state = rspotify::spotify::util::generate_random_string(16);
let oauth = SpotifyOAuth::default();
//let callback = oauth.redirect_uri.clone();
let oauth = oauth
.scope("playlist-read-private, playlist-read-collaborative, user-read-private, user-follow-read, user-library-read")
//.redirect_uri(format!("{}/{}", callback, &state).as_ref())
.build();
let auth_url = oauth.get_authorize_url(Some(&state), None);
match CACHE.lock() {
Ok(mut guard) => {
guard.insert(name, oauth);
Ok(Redirect::to(auth_url))
}
Err(_) => Err(status::Custom(
Status::ImATeapot,
"Internal Server Error".to_owned(),
)),
}
/*match get_token(&mut oauth) {
Some(token_info) => {
let client_credential = SpotifyClientCredentials::default()
.token_info(token_info)
.build();
// Or set client_id and client_secret explictly
// let client_credential = SpotifyClientCredentials::default()
// .client_id("this-is-my-client-id")
// .client_secret("this-is-my-client-secret")
// .build();
let spotify = Spotify::default()
.client_credentials_manager(client_credential)
.build();
}
None => {}
}*/
}
|
