this repo has no description
lewis.moe
1use super::super::{
2 AuthFlowState, AuthorizationRequestParameters, ClientAuth, OAuthError, RequestData,
3};
4use super::helpers::{from_json, to_json};
5use sqlx::PgPool;
6
7pub async fn get_authorization_request_with_state(
8 pool: &PgPool,
9 request_id: &str,
10) -> Result<Option<(RequestData, AuthFlowState)>, OAuthError> {
11 match get_authorization_request(pool, request_id).await? {
12 Some(data) => {
13 let state = AuthFlowState::from_request_data(&data);
14 Ok(Some((data, state)))
15 }
16 None => Ok(None),
17 }
18}
19
20pub async fn create_authorization_request(
21 pool: &PgPool,
22 request_id: &str,
23 data: &RequestData,
24) -> Result<(), OAuthError> {
25 let client_auth_json = match &data.client_auth {
26 Some(ca) => Some(to_json(ca)?),
27 None => None,
28 };
29 let parameters_json = to_json(&data.parameters)?;
30 sqlx::query!(
31 r#"
32 INSERT INTO oauth_authorization_request
33 (id, did, device_id, client_id, client_auth, parameters, expires_at, code)
34 VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
35 "#,
36 request_id,
37 data.did,
38 data.device_id,
39 data.client_id,
40 client_auth_json,
41 parameters_json,
42 data.expires_at,
43 data.code,
44 )
45 .execute(pool)
46 .await?;
47 Ok(())
48}
49
50pub async fn get_authorization_request(
51 pool: &PgPool,
52 request_id: &str,
53) -> Result<Option<RequestData>, OAuthError> {
54 let row = sqlx::query!(
55 r#"
56 SELECT did, device_id, client_id, client_auth, parameters, expires_at, code, controller_did
57 FROM oauth_authorization_request
58 WHERE id = $1
59 "#,
60 request_id
61 )
62 .fetch_optional(pool)
63 .await?;
64 match row {
65 Some(r) => {
66 let client_auth: Option<ClientAuth> = match r.client_auth {
67 Some(v) => Some(from_json(v)?),
68 None => None,
69 };
70 let parameters: AuthorizationRequestParameters = from_json(r.parameters)?;
71 Ok(Some(RequestData {
72 client_id: r.client_id,
73 client_auth,
74 parameters,
75 expires_at: r.expires_at,
76 did: r.did,
77 device_id: r.device_id,
78 code: r.code,
79 controller_did: r.controller_did,
80 }))
81 }
82 None => Ok(None),
83 }
84}
85
86pub async fn set_authorization_did(
87 pool: &PgPool,
88 request_id: &str,
89 did: &str,
90 device_id: Option<&str>,
91) -> Result<(), OAuthError> {
92 sqlx::query!(
93 r#"
94 UPDATE oauth_authorization_request
95 SET did = $2, device_id = $3
96 WHERE id = $1
97 "#,
98 request_id,
99 did,
100 device_id
101 )
102 .execute(pool)
103 .await?;
104 Ok(())
105}
106
107pub async fn update_authorization_request(
108 pool: &PgPool,
109 request_id: &str,
110 did: &str,
111 device_id: Option<&str>,
112 code: &str,
113) -> Result<(), OAuthError> {
114 sqlx::query!(
115 r#"
116 UPDATE oauth_authorization_request
117 SET did = $2, device_id = $3, code = $4
118 WHERE id = $1
119 "#,
120 request_id,
121 did,
122 device_id,
123 code
124 )
125 .execute(pool)
126 .await?;
127 Ok(())
128}
129
130pub async fn consume_authorization_request_by_code(
131 pool: &PgPool,
132 code: &str,
133) -> Result<Option<RequestData>, OAuthError> {
134 let row = sqlx::query!(
135 r#"
136 DELETE FROM oauth_authorization_request
137 WHERE code = $1
138 RETURNING did, device_id, client_id, client_auth, parameters, expires_at, code, controller_did
139 "#,
140 code
141 )
142 .fetch_optional(pool)
143 .await?;
144 match row {
145 Some(r) => {
146 let client_auth: Option<ClientAuth> = match r.client_auth {
147 Some(v) => Some(from_json(v)?),
148 None => None,
149 };
150 let parameters: AuthorizationRequestParameters = from_json(r.parameters)?;
151 Ok(Some(RequestData {
152 client_id: r.client_id,
153 client_auth,
154 parameters,
155 expires_at: r.expires_at,
156 did: r.did,
157 device_id: r.device_id,
158 code: r.code,
159 controller_did: r.controller_did,
160 }))
161 }
162 None => Ok(None),
163 }
164}
165
166pub async fn delete_authorization_request(
167 pool: &PgPool,
168 request_id: &str,
169) -> Result<(), OAuthError> {
170 sqlx::query!(
171 r#"
172 DELETE FROM oauth_authorization_request WHERE id = $1
173 "#,
174 request_id
175 )
176 .execute(pool)
177 .await?;
178 Ok(())
179}
180
181pub async fn delete_expired_authorization_requests(pool: &PgPool) -> Result<u64, OAuthError> {
182 let result = sqlx::query!(
183 r#"
184 DELETE FROM oauth_authorization_request
185 WHERE expires_at < NOW()
186 "#
187 )
188 .execute(pool)
189 .await?;
190 Ok(result.rows_affected())
191}
192
193pub async fn mark_request_authenticated(
194 pool: &PgPool,
195 request_id: &str,
196 did: &str,
197 device_id: Option<&str>,
198) -> Result<(), OAuthError> {
199 sqlx::query!(
200 r#"
201 UPDATE oauth_authorization_request
202 SET did = $2, device_id = $3
203 WHERE id = $1
204 "#,
205 request_id,
206 did,
207 device_id
208 )
209 .execute(pool)
210 .await?;
211 Ok(())
212}
213
214pub async fn update_request_scope(
215 pool: &PgPool,
216 request_id: &str,
217 scope: &str,
218) -> Result<(), OAuthError> {
219 sqlx::query!(
220 r#"
221 UPDATE oauth_authorization_request
222 SET parameters = jsonb_set(parameters, '{scope}', to_jsonb($2::text))
223 WHERE id = $1
224 "#,
225 request_id,
226 scope
227 )
228 .execute(pool)
229 .await?;
230 Ok(())
231}
232
233pub async fn set_controller_did(
234 pool: &PgPool,
235 request_id: &str,
236 controller_did: &str,
237) -> Result<(), OAuthError> {
238 sqlx::query!(
239 r#"
240 UPDATE oauth_authorization_request
241 SET controller_did = $2
242 WHERE id = $1
243 "#,
244 request_id,
245 controller_did
246 )
247 .execute(pool)
248 .await?;
249 Ok(())
250}
251
252pub async fn set_request_did(pool: &PgPool, request_id: &str, did: &str) -> Result<(), OAuthError> {
253 sqlx::query!(
254 r#"
255 UPDATE oauth_authorization_request
256 SET did = $2
257 WHERE id = $1
258 "#,
259 request_id,
260 did
261 )
262 .execute(pool)
263 .await?;
264 Ok(())
265}