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