Upload main.rs

src/main.rs

@@ -1702,6 +1702,160 @@ async fn oauth_flow(Json(req): Json<OauthFlowReq>) -> impl IntoResponse {
     }
 }
 
+#[derive(Debug, Deserialize)]
+struct OauthRecoReq {
+    access_token: String,
+    index: Option<u32>,
+    limit: Option<u32>,
+}
+
+async fn oauth_reco_playlists(Json(req): Json<OauthRecoReq>) -> 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(20).clamp(1, 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::SERVICE_UNAVAILABLE, e),
+    };
+    let uid = me.get("id").and_then(|x| x.as_i64()).unwrap_or(0);
+    if uid <= 0 {
+        return json_error(StatusCode::SERVICE_UNAVAILABLE, "api:no_user_id");
+    }
+    let path = format!("/user/{uid}/recommendations/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::SERVICE_UNAVAILABLE, e),
+    }
+}
+
+async fn oauth_reco_albums(Json(req): Json<OauthRecoReq>) -> 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(20).clamp(1, 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::SERVICE_UNAVAILABLE, e),
+    };
+    let uid = me.get("id").and_then(|x| x.as_i64()).unwrap_or(0);
+    if uid <= 0 {
+        return json_error(StatusCode::SERVICE_UNAVAILABLE, "api:no_user_id");
+    }
+    let path = format!("/user/{uid}/recommendations/albums");
+    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::SERVICE_UNAVAILABLE, e),
+    }
+}
+
+async fn oauth_reco_artists(Json(req): Json<OauthRecoReq>) -> 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(20).clamp(1, 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::SERVICE_UNAVAILABLE, e),
+    };
+    let uid = me.get("id").and_then(|x| x.as_i64()).unwrap_or(0);
+    if uid <= 0 {
+        return json_error(StatusCode::SERVICE_UNAVAILABLE, "api:no_user_id");
+    }
+    let path = format!("/user/{uid}/recommendations/artists");
+    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::SERVICE_UNAVAILABLE, e),
+    }
+}
+
+async fn oauth_reco_tracks(Json(req): Json<OauthRecoReq>) -> 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(40).clamp(1, 100).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::SERVICE_UNAVAILABLE, e),
+    };
+    let uid = me.get("id").and_then(|x| x.as_i64()).unwrap_or(0);
+    if uid <= 0 {
+        return json_error(StatusCode::SERVICE_UNAVAILABLE, "api:no_user_id");
+    }
+    let path = format!("/user/{uid}/recommendations/tracks");
+    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::SERVICE_UNAVAILABLE, e),
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct OauthHistoryReq {
+    access_token: String,
+    index: Option<u32>,
+    limit: Option<u32>,
+}
+
+async fn oauth_history(Json(req): Json<OauthHistoryReq>) -> 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).clamp(1, 100).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::SERVICE_UNAVAILABLE, e),
+    };
+    let uid = me.get("id").and_then(|x| x.as_i64()).unwrap_or(0);
+    if uid <= 0 {
+        return json_error(StatusCode::SERVICE_UNAVAILABLE, "api:no_user_id");
+    }
+    let path = format!("/user/{uid}/history");
+    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::SERVICE_UNAVAILABLE, e),
+    }
+}
+
 #[tokio::main]
 async fn main() {
     let bind_addr = std::env::var("BIND_ADDR").unwrap_or("[::]".to_string());
@@ -1740,6 +1894,11 @@ async fn main() {
         .route("/oauth/playlist_tracks", post(oauth_playlist_tracks))
         .route("/oauth/arl", post(oauth_arl))
         .route("/oauth/flow", post(oauth_flow))
+        .route("/oauth/reco_playlists", post(oauth_reco_playlists))
+        .route("/oauth/reco_albums", post(oauth_reco_albums))
+        .route("/oauth/reco_artists", post(oauth_reco_artists))
+        .route("/oauth/reco_tracks", post(oauth_reco_tracks))
+        .route("/oauth/history", post(oauth_history))
         .with_state(state)
         .layer(cors)
         .layer(CompressionLayer::new())