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 => {}
+    }*/
+}