diff options
Diffstat (limited to 'src/serve.rs')
-rw-r--r-- | src/serve.rs | 124 |
1 files changed, 124 insertions, 0 deletions
diff --git a/src/serve.rs b/src/serve.rs new file mode 100644 index 0000000..0dff5da --- /dev/null +++ b/src/serve.rs @@ -0,0 +1,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 => {} + }*/ +} |