1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/*
This file is part of jellything (https://codeberg.org/metamuffin/jellything)
which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
Copyright (C) 2026 metamuffin <metamuffin.org>
*/
use crate::{
State,
auth::token_to_user,
ui::error::{MyError, MyResult},
};
use anyhow::anyhow;
use jellycommon::{
USER_ADMIN,
jellyobject::{Object, ObjectBuffer},
};
use jellyui::RenderInfo;
use rocket::{
Request, async_trait,
http::{MediaType, Status},
request::{FromRequest, Outcome},
};
use std::sync::Arc;
pub struct RequestInfo<'a> {
pub lang: &'a str,
pub accept: Accept,
pub debug: &'a str,
pub user: Option<ObjectBuffer>,
pub state: Arc<State>,
}
#[async_trait]
impl<'r> FromRequest<'r> for RequestInfo<'r> {
type Error = MyError;
async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
match Self::from_request_ut(request).await {
Ok(a) => Outcome::Success(a),
Err(a) => Outcome::Error((Status::BadRequest, a)),
}
}
}
impl<'a> RequestInfo<'a> {
pub async fn from_request_ut(request: &'a Request<'_>) -> MyResult<Self> {
let state: &Arc<State> = request.rocket().state().unwrap();
Ok(Self {
lang: accept_language(request),
accept: Accept::from_request_ut(request),
user: user_from_request(state, request)?,
state: state.clone(),
debug: request
.query_value::<&str>("debug")
.transpose()
.unwrap()
.unwrap_or("none"),
})
}
pub fn require_user(&'a self) -> MyResult<Object<'a>> {
self.user
.as_ref()
.map(|u| u.as_object())
.ok_or(MyError(anyhow!("user required")))
}
pub fn require_admin(&'a self) -> MyResult<Object<'a>> {
let user = self.require_user()?;
if !user.has(USER_ADMIN.0) {
Err(anyhow!("admin required"))?
}
Ok(user)
}
pub fn render_info(&'a self) -> RenderInfo<'a> {
RenderInfo {
lang: self.lang,
status_message: None,
user: self.user.as_ref().map(|u| u.as_object()),
config: &self.state.config.ui,
}
}
}
#[derive(Debug, Default)]
pub enum Accept {
#[default]
Other,
Json,
Image,
Media,
Html,
}
impl Accept {
pub fn from_request_ut(request: &Request) -> Self {
if let Some(a) = request.accept() {
if a.preferred().exact_eq(&MediaType::JSON) {
Accept::Json
} else {
Accept::Other
}
} else {
Accept::Other
}
}
pub fn is_json(&self) -> bool {
matches!(self, Self::Json)
}
}
fn accept_language<'a>(request: &'a Request<'_>) -> &'a str {
request
.headers()
.get_one("accept-language")
.and_then(|h| {
h.split(",")
.filter_map(|e| {
let code = e.split(";").next()?;
let code = code.split_once("-").unwrap_or((code, "")).0;
Some(code)
})
.next()
})
.unwrap_or("en")
}
fn user_from_request(state: &State, req: &Request<'_>) -> Result<Option<ObjectBuffer>, MyError> {
let Some(token) = req
.query_value("session")
.map(|e| e.unwrap())
.or_else(|| req.query_value("api_key").map(|e| e.unwrap()))
.or_else(|| req.headers().get_one("X-MediaBrowser-Token"))
.or_else(|| {
req.headers()
.get_one("Authorization")
.and_then(parse_jellyfin_auth)
}) // for jellyfin compat
.or(req.cookies().get("session").map(|cookie| cookie.value()))
else {
return Ok(None);
};
// jellyfin urlescapes the token for *some* requests
let token = token.replace("%3D", "=");
Ok(Some(token_to_user(state, &token)?))
}
fn parse_jellyfin_auth(h: &str) -> Option<&str> {
for tok in h.split(" ") {
if let Some(tok) = tok.strip_prefix("Token=\"")
&& let Some(tok) = tok.strip_suffix("\"")
{
return Some(tok);
}
}
None
}
|
