A decentralized music tracking and discovery platform built on AT Protocol 🎵
rocksky.app
spotify
atproto
lastfm
musicbrainz
scrobbling
listenbrainz
[scrobbler] fix validate-token issue
+55
-11
+2
-2
crates/connect/src/players/kodi.rs
+2
-2
crates/connect/src/players/kodi.rs
···
3
3
use super::Player;
4
4
use anyhow::Error;
5
5
use async_trait::async_trait;
6
-
use base64::{engine::general_purpose::STANDARD, Engine as _};
6
+
use base64::{Engine as _, engine::general_purpose::STANDARD};
7
7
use jsonrpsee::{
8
8
core::{
9
9
client::ClientT,
···
13
13
rpc_params,
14
14
};
15
15
use reqwest::header::HeaderMap;
16
-
use serde_json::{json, Value};
16
+
use serde_json::{Value, json};
17
17
use tokio::sync::mpsc::Sender;
18
18
19
19
#[derive(Clone)]
+2
-2
crates/connect/src/websocket.rs
+2
-2
crates/connect/src/websocket.rs
···
3
3
use anyhow::Error;
4
4
use futures_util::{SinkExt, StreamExt};
5
5
use owo_colors::OwoColorize;
6
-
use serde_json::{json, Value};
6
+
use serde_json::{Value, json};
7
7
use tokio::sync::Mutex;
8
8
use tokio_tungstenite::connect_async;
9
9
10
-
use crate::players::{get_current_player, Player};
10
+
use crate::players::{Player, get_current_player};
11
11
12
12
pub async fn connect_to_rocksky_websocket(token: String) -> Result<(), Error> {
13
13
let rocksky_ws =
+51
-7
crates/scrobbler/src/handlers/mod.rs
+51
-7
crates/scrobbler/src/handlers/mod.rs
···
12
12
use crate::cache::Cache;
13
13
use crate::listenbrainz::submit::submit_listens;
14
14
use crate::listenbrainz::types::SubmitListensRequest;
15
-
use crate::BANNER;
15
+
use crate::{repo, BANNER};
16
16
17
17
pub mod scrobble;
18
18
pub mod v1;
···
123
123
}
124
124
125
125
#[get("/1/validate-token")]
126
-
pub async fn handle_validate_token(_req: HttpRequest) -> impl Responder {
127
-
HttpResponse::Ok().json(serde_json::json!({
128
-
"code": 200,
129
-
"message": "Token valid.",
130
-
"valid": true,
131
-
}))
126
+
pub async fn handle_validate_token(
127
+
data: web::Data<Arc<Pool<Postgres>>>,
128
+
req: HttpRequest,
129
+
) -> impl Responder {
130
+
let pool = data.get_ref();
131
+
let authorization = req.headers().get("Authorization");
132
+
133
+
if authorization.is_none() {
134
+
return HttpResponse::Ok().json(serde_json::json!({
135
+
"code": 200,
136
+
"message": "Token valid.",
137
+
"valid": true,
138
+
}));
139
+
}
140
+
141
+
let authorization = authorization.unwrap();
142
+
let token = match authorization.to_str() {
143
+
Ok(token) => token
144
+
.trim_start_matches("Token ")
145
+
.trim_start_matches("Bearer ")
146
+
.trim_start_matches("token ")
147
+
.trim_start_matches("bearer "),
148
+
Err(_) => return HttpResponse::Unauthorized().finish(),
149
+
};
150
+
151
+
match repo::user::get_user_by_apikey(pool, token).await {
152
+
Ok(Some(user)) => {
153
+
return HttpResponse::Ok().json(serde_json::json!({
154
+
"code": 200,
155
+
"message": "Token valid.",
156
+
"valid": true,
157
+
"user_name": user.handle,
158
+
"permissions": vec![
159
+
"recording-metadata-write",
160
+
"recording-metadata-read"
161
+
],
162
+
}));
163
+
}
164
+
Ok(None) => {
165
+
return HttpResponse::Ok().json(serde_json::json!({
166
+
"code": 200,
167
+
"message": "Token invalid.",
168
+
"valid": false,
169
+
}));
170
+
}
171
+
Err(e) => {
172
+
println!("Error validating token: {}", e);
173
+
return HttpResponse::InternalServerError().finish();
174
+
}
175
+
}
132
176
}
133
177
134
178
pub async fn call_method(