Upload 2 files

src/main.rs

@@ -1,14 +1,15 @@
 use axum::{
     routing::{get, post},
     http::StatusCode,
-    response::IntoResponse,
-    extract::{Json, State, Query},
+    response::{IntoResponse, Html},
+    extract::{Json, State, Query, Form},
     Router,
 };
 use tower_http::{cors::{CorsLayer, Any}, compression::CompressionLayer, trace::TraceLayer};
 use http::{Method, header::CONTENT_TYPE};
 use serde_json::json;
 use serde::Deserialize;
+use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
 use bytes::Bytes;
 use futures_util::StreamExt;
@@ -27,6 +28,12 @@ type BoxErr = Box<dyn std::error::Error + Send + Sync + 'static>;
 mod api;
 use api::{APIClient, APIError, Format};
 
+#[derive(Clone)]
+struct AppState {
+    api: Arc<RwLock<APIClient>>,
+    pair: Arc<RwLock<HashMap<String, PairSession>>>,
+}
+
 fn json_error(status: StatusCode, message: impl Into<String>) -> axum::response::Response {
     (status, Json(json!({ "error": message.into() }))).into_response()
 }
@@ -53,7 +60,7 @@ struct RequestParams {
     arl: Option<String>,
 }
 
-async fn get_url(State(state): State<Arc<RwLock<APIClient>>>, Json(req): Json<RequestParams>) -> impl IntoResponse {
+async fn get_url(State(state): State<AppState>, Json(req): Json<RequestParams>) -> impl IntoResponse {
     if req.formats.is_empty() {
         return (StatusCode::BAD_REQUEST, "Format list cannot be empty".to_string());
     }
@@ -64,7 +71,7 @@ async fn get_url(State(state): State<Arc<RwLock<APIClient>>>, Json(req): Json<Re
     let mut client = if let Some(arl) = req.arl.clone().filter(|s| !s.trim().is_empty()) {
         APIClient::new_with_arl(arl)
     } else {
-        state.read().unwrap().clone()
+        state.api.read().unwrap().clone()
     };
     let old_license = client.license_token.clone();
 
@@ -89,7 +96,7 @@ async fn get_url(State(state): State<Arc<RwLock<APIClient>>>, Json(req): Json<Re
     };
 
     if req.arl.is_none() && client.license_token != old_license {
-        let mut client_write = state.write().unwrap();
+        let mut client_write = state.api.write().unwrap();
         *client_write = client;
     }
 
@@ -167,7 +174,7 @@ struct StreamParams {
     arl: Option<String>,
 }
 
-async fn stream(State(state): State<Arc<RwLock<APIClient>>>, Query(q): Query<StreamParams>) -> impl IntoResponse {
+async fn stream(State(state): State<AppState>, Query(q): Query<StreamParams>) -> impl IntoResponse {
     let formats = match q.format.as_deref().unwrap_or("AUTO") {
         "FLAC" => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
         "MP3_320" => vec![Format::MP3_320, Format::MP3_128],
@@ -179,7 +186,7 @@ async fn stream(State(state): State<Arc<RwLock<APIClient>>>, Query(q): Query<Str
     let mut client = if let Some(arl) = q.arl.clone().filter(|s| !s.trim().is_empty()) {
         APIClient::new_with_arl(arl)
     } else {
-        state.read().unwrap().clone()
+        state.api.read().unwrap().clone()
     };
 
     let resp: Result<DeezerTrackList, APIError> = client
@@ -545,7 +552,9 @@ async fn login(Json(req): Json<LoginReq>) -> impl IntoResponse {
         .build()
         .unwrap();
 
+    let mut access_token_out: Option<String> = None;
     if let Ok(access_token) = oauth_access_token(&client, &email, &pass).await {
+        access_token_out = Some(access_token.clone());
         let _ = client
             .get("https://api.deezer.com/platform/generic/track/80085")
             .header("Authorization", format!("Bearer {}", access_token))
@@ -617,7 +626,309 @@ async fn login(Json(req): Json<LoginReq>) -> impl IntoResponse {
         return json_error(StatusCode::BAD_GATEWAY, "no arl");
     }
 
-    (StatusCode::OK, Json(json!({ "arl": arl, "token": token, "uid": uid }))).into_response()
+    (StatusCode::OK, Json(json!({ "arl": arl, "token": token, "uid": uid, "access_token": access_token_out }))).into_response()
+}
+
+#[derive(Clone)]
+struct PairSession {
+    created_ms: u128,
+    access_token: Option<String>,
+    user_id: Option<String>,
+    error: Option<String>,
+}
+
+fn gen_pair_code() -> String {
+    let ms = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_millis())
+        .unwrap_or(0);
+    let hex = format!("{:x}", md5::compute(format!("pair:{ms}:{SECRET}").as_bytes()));
+    hex.chars().take(10).collect::<String>()
+}
+
+#[derive(Deserialize)]
+struct PairStatusQuery {
+    code: String,
+}
+
+async fn pair_start(State(state): State<AppState>) -> impl IntoResponse {
+    let code = gen_pair_code();
+    let created_ms = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_millis())
+        .unwrap_or(0);
+    {
+        let mut map = state.pair.write().unwrap();
+        map.insert(
+            code.clone(),
+            PairSession {
+                created_ms,
+                access_token: None,
+                user_id: None,
+                error: None,
+            },
+        );
+    }
+    (StatusCode::OK, Json(json!({ "code": code }))).into_response()
+}
+
+async fn pair_status(State(state): State<AppState>, Query(q): Query<PairStatusQuery>) -> impl IntoResponse {
+    let code = q.code.trim().to_string();
+    if code.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "code required");
+    }
+
+    let map = state.pair.read().unwrap();
+    let Some(sess) = map.get(&code) else {
+        return json_error(StatusCode::NOT_FOUND, "no such code");
+    };
+
+    if let Some(err) = &sess.error {
+        return (StatusCode::OK, Json(json!({ "status": "error", "error": err }))).into_response();
+    }
+    if let Some(tok) = &sess.access_token {
+        return (
+            StatusCode::OK,
+            Json(json!({ "status": "ok", "access_token": tok, "user_id": sess.user_id })),
+        )
+            .into_response();
+    }
+
+    (StatusCode::OK, Json(json!({ "status": "pending" }))).into_response()
+}
+
+#[derive(Deserialize)]
+struct PairPageQuery {
+    code: Option<String>,
+}
+
+async fn pair_page(Query(q): Query<PairPageQuery>) -> impl IntoResponse {
+    let code = q.code.unwrap_or_default();
+    let safe_code = htmlesc(&code);
+    let html = format!(
+        "<!doctype html><html><head><meta charset=\"utf-8\"><meta name=\"viewport\" content=\"width=device-width,initial-scale=1\">\
+        <title>Deezer Login</title>\
+        <style>body{{font-family:system-ui,-apple-system,Segoe UI,Roboto,Arial,sans-serif;background:#0b0b0b;color:#fff;margin:0;padding:20px}}\
+        .box{{max-width:420px;margin:0 auto;background:#151515;padding:18px;border-radius:12px}}\
+        input{{width:100%;padding:12px 14px;margin:10px 0;border-radius:10px;border:1px solid #333;background:#0f0f0f;color:#fff;font-size:16px}}\
+        button{{width:100%;padding:12px 14px;border-radius:10px;border:0;background:#1db954;color:#000;font-weight:700;font-size:16px}}\
+        .muted{{color:#aaa;font-size:13px;line-height:1.35}}</style>\
+        </head><body><div class=\"box\">\
+        <h2 style=\"margin:0 0 6px\">Вход Deezer</h2>\
+        <div class=\"muted\">Код: <b>{safe_code}</b></div>\
+        <form method=\"POST\" action=\"/pair/complete\">\
+            <input type=\"hidden\" name=\"code\" value=\"{safe_code}\">\
+            <input name=\"email\" type=\"email\" placeholder=\"Email\" autocomplete=\"username\" required>\
+            <input name=\"password\" type=\"password\" placeholder=\"Пароль\" autocomplete=\"current-password\" required>\
+            <button type=\"submit\">Войти</button>\
+        </form>\
+        <p class=\"muted\" style=\"margin:12px 0 0\">Пароль используется только для получения токена доступа и не сохраняется.</p>\
+        </div></body></html>"
+    );
+    Html(html)
+}
+
+#[derive(Deserialize)]
+struct PairCompleteForm {
+    code: String,
+    email: String,
+    password: String,
+}
+
+fn htmlesc(s: &str) -> String {
+    s.replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+        .replace('"', "&quot;")
+        .replace('\'', "&#39;")
+}
+
+async fn api_deezer_get(
+    client: &reqwest::Client,
+    path: &str,
+    access_token: &str,
+    extra: &[(&str, String)],
+) -> Result<serde_json::Value, String> {
+    let url = format!("https://api.deezer.com{path}");
+    let mut req = client
+        .get(url)
+        .header("Authorization", format!("Bearer {}", access_token))
+        .header(ACCEPT, "*/*")
+        .header("Accept-Language", "en-US,en;q=0.9")
+        .header(
+            "User-Agent",
+            "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0",
+        )
+        .query(&[("access_token", access_token)]);
+    if !extra.is_empty() {
+        req = req.query(extra);
+    }
+    let r = req.send().await.map_err(|_| "api:network".to_string())?;
+    let status = r.status();
+    let text = r.text().await.map_err(|_| "api:read".to_string())?;
+    let v: serde_json::Value = serde_json::from_str(&text).map_err(|_| {
+        let snip: String = text.chars().take(200).collect();
+        format!("api:parse:{}:{}", status.as_u16(), snip)
+    })?;
+    if let Some(e) = v.get("error") {
+        if e.is_object() {
+            let code = e.get("code").and_then(|x| x.as_i64()).unwrap_or(0);
+            let msg = e.get("message").and_then(|x| x.as_str()).unwrap_or("error");
+            return Err(format!("api:{code}:{msg}"));
+        }
+        return Err("api:error".to_string());
+    }
+    Ok(v)
+}
+
+async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairCompleteForm>) -> impl IntoResponse {
+    let code = f.code.trim().to_string();
+    let email = f.email.trim().to_string();
+    let password = f.password;
+    if code.is_empty() || email.is_empty() || password.is_empty() {
+        return Html("<h3>Нужны code/email/password</h3>".to_string()).into_response();
+    }
+
+    {
+        let map = state.pair.read().unwrap();
+        if !map.contains_key(&code) {
+            return Html("<h3>Код не найден или истёк</h3>".to_string()).into_response();
+        }
+    }
+
+    let jar = Arc::new(Jar::default());
+    let url_deezer = "https://www.deezer.com".parse::<Url>().unwrap();
+    jar.add_cookie_str("comeback=1; Domain=.deezer.com", &url_deezer);
+    let client = reqwest::Client::builder()
+        .cookie_provider(jar)
+        .timeout(std::time::Duration::from_secs(20))
+        .build()
+        .unwrap();
+
+    let pass_md5 = format!("{:x}", md5::compute(password.as_bytes()));
+    let access_token = match oauth_access_token(&client, &email, &pass_md5).await {
+        Ok(t) => t,
+        Err(e) => {
+            let mut map = state.pair.write().unwrap();
+            if let Some(s) = map.get_mut(&code) {
+                s.error = Some(e.clone());
+            }
+            return Html(format!("<h3>Ошибка входа</h3><pre>{}</pre>", htmlesc(&e))).into_response();
+        }
+    };
+
+    let _ = client
+        .get("https://api.deezer.com/platform/generic/track/80085")
+        .header("Authorization", format!("Bearer {}", access_token))
+        .send()
+        .await;
+
+    let me = match api_deezer_get(&client, "/user/me", &access_token, &[]).await {
+        Ok(v) => v,
+        Err(e) => {
+            let mut map = state.pair.write().unwrap();
+            if let Some(s) = map.get_mut(&code) {
+                s.error = Some(e.clone());
+            }
+            return Html(format!("<h3>Ошибка Deezer API</h3><pre>{}</pre>", htmlesc(&e))).into_response();
+        }
+    };
+    let uid = me.get("id").and_then(|x| x.as_i64()).map(|n| n.to_string());
+
+    {
+        let mut map = state.pair.write().unwrap();
+        if let Some(s) = map.get_mut(&code) {
+            s.access_token = Some(access_token);
+            s.user_id = uid;
+            s.error = None;
+        }
+    }
+
+    Html("<h3>Готово</h3><p>Вернись на ТВ — плагин подключится автоматически.</p>".to_string()).into_response()
+}
+
+#[derive(Debug, Deserialize)]
+struct OauthMeReq {
+    access_token: String,
+}
+
+async fn oauth_me(Json(req): Json<OauthMeReq>) -> impl IntoResponse {
+    let token = req.access_token.trim().to_string();
+    if token.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "access_token required");
+    }
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(15))
+        .build()
+        .unwrap();
+    match api_deezer_get(&client, "/user/me", &token, &[]).await {
+        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
+        Err(e) => json_error(StatusCode::BAD_GATEWAY, e),
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct OauthPlaylistsReq {
+    access_token: String,
+    index: Option<u32>,
+    limit: Option<u32>,
+}
+
+async fn oauth_playlists(Json(req): Json<OauthPlaylistsReq>) -> impl IntoResponse {
+    let token = req.access_token.trim().to_string();
+    if token.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "access_token required");
+    }
+    let index = req.index.unwrap_or(0).to_string();
+    let limit = req.limit.unwrap_or(50).to_string();
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(15))
+        .build()
+        .unwrap();
+    let me = match api_deezer_get(&client, "/user/me", &token, &[]).await {
+        Ok(v) => v,
+        Err(e) => return json_error(StatusCode::BAD_GATEWAY, e),
+    };
+    let uid = me.get("id").and_then(|x| x.as_i64()).unwrap_or(0);
+    if uid <= 0 {
+        return json_error(StatusCode::BAD_GATEWAY, "api:no_user_id");
+    }
+    let path = format!("/user/{uid}/playlists");
+    let extra = [("index", index), ("limit", limit)];
+    match api_deezer_get(&client, &path, &token, &extra).await {
+        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
+        Err(e) => json_error(StatusCode::BAD_GATEWAY, e),
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct OauthPlaylistTracksReq {
+    access_token: String,
+    playlist_id: u64,
+    index: Option<u32>,
+    limit: Option<u32>,
+}
+
+async fn oauth_playlist_tracks(Json(req): Json<OauthPlaylistTracksReq>) -> impl IntoResponse {
+    let token = req.access_token.trim().to_string();
+    if token.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "access_token required");
+    }
+    if req.playlist_id == 0 {
+        return json_error(StatusCode::BAD_REQUEST, "playlist_id required");
+    }
+    let index = req.index.unwrap_or(0).to_string();
+    let limit = req.limit.unwrap_or(100).to_string();
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(15))
+        .build()
+        .unwrap();
+    let path = format!("/playlist/{}/tracks", req.playlist_id);
+    let extra = [("index", index), ("limit", limit)];
+    match api_deezer_get(&client, &path, &token, &extra).await {
+        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
+        Err(e) => json_error(StatusCode::BAD_GATEWAY, e),
+    }
 }
 
 #[tokio::main]
@@ -626,7 +937,10 @@ async fn main() {
     let port = std::env::var("PORT").unwrap_or("8000".to_string());
     let port: u16 = port.parse().unwrap_or(8000);
 
-    let shared_state = Arc::new(RwLock::new(APIClient::new()));
+    let state = AppState {
+        api: Arc::new(RwLock::new(APIClient::new())),
+        pair: Arc::new(RwLock::new(HashMap::new())),
+    };
 
     let cors = CorsLayer::new()
         .allow_origin(Any)
@@ -644,7 +958,14 @@ async fn main() {
         .route("/playlists", post(playlists))
         .route("/playlist", post(playlist_tracks))
         .route("/login", post(login))
-        .with_state(shared_state)
+        .route("/pair/start", get(pair_start))
+        .route("/pair/status", get(pair_status))
+        .route("/pair", get(pair_page))
+        .route("/pair/complete", post(pair_complete))
+        .route("/oauth/me", post(oauth_me))
+        .route("/oauth/playlists", post(oauth_playlists))
+        .route("/oauth/playlist_tracks", post(oauth_playlist_tracks))
+        .with_state(state)
         .layer(cors)
         .layer(CompressionLayer::new())
         .layer(TraceLayer::new_for_http());