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