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
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 }))
65 }
66 None => Ok(None),
67 }
68}
69
70pub async fn set_authorization_did(
71 pool: &PgPool,
72 request_id: &str,
73 did: &str,
74 device_id: Option<&str>,
75) -> Result<(), OAuthError> {
76 sqlx::query!(
77 r#"
78 UPDATE oauth_authorization_request
79 SET did = $2, device_id = $3
80 WHERE id = $1
81 "#,
82 request_id,
83 did,
84 device_id
85 )
86 .execute(pool)
87 .await?;
88 Ok(())
89}
90
91pub async fn update_authorization_request(
92 pool: &PgPool,
93 request_id: &str,
94 did: &str,
95 device_id: Option<&str>,
96 code: &str,
97) -> Result<(), OAuthError> {
98 sqlx::query!(
99 r#"
100 UPDATE oauth_authorization_request
101 SET did = $2, device_id = $3, code = $4
102 WHERE id = $1
103 "#,
104 request_id,
105 did,
106 device_id,
107 code
108 )
109 .execute(pool)
110 .await?;
111 Ok(())
112}
113
114pub async fn consume_authorization_request_by_code(
115 pool: &PgPool,
116 code: &str,
117) -> Result<Option<RequestData>, OAuthError> {
118 let row = sqlx::query!(
119 r#"
120 DELETE FROM oauth_authorization_request
121 WHERE code = $1
122 RETURNING did, device_id, client_id, client_auth, parameters, expires_at, code
123 "#,
124 code
125 )
126 .fetch_optional(pool)
127 .await?;
128 match row {
129 Some(r) => {
130 let client_auth: Option<ClientAuth> = match r.client_auth {
131 Some(v) => Some(from_json(v)?),
132 None => None,
133 };
134 let parameters: AuthorizationRequestParameters = from_json(r.parameters)?;
135 Ok(Some(RequestData {
136 client_id: r.client_id,
137 client_auth,
138 parameters,
139 expires_at: r.expires_at,
140 did: r.did,
141 device_id: r.device_id,
142 code: r.code,
143 }))
144 }
145 None => Ok(None),
146 }
147}
148
149pub async fn delete_authorization_request(
150 pool: &PgPool,
151 request_id: &str,
152) -> Result<(), OAuthError> {
153 sqlx::query!(
154 r#"
155 DELETE FROM oauth_authorization_request WHERE id = $1
156 "#,
157 request_id
158 )
159 .execute(pool)
160 .await?;
161 Ok(())
162}
163
164pub async fn delete_expired_authorization_requests(pool: &PgPool) -> Result<u64, OAuthError> {
165 let result = sqlx::query!(
166 r#"
167 DELETE FROM oauth_authorization_request
168 WHERE expires_at < NOW()
169 "#
170 )
171 .execute(pool)
172 .await?;
173 Ok(result.rows_affected())
174}
175
176pub async fn mark_request_authenticated(
177 pool: &PgPool,
178 request_id: &str,
179 did: &str,
180 device_id: Option<&str>,
181) -> Result<(), OAuthError> {
182 sqlx::query!(
183 r#"
184 UPDATE oauth_authorization_request
185 SET did = $2, device_id = $3
186 WHERE id = $1
187 "#,
188 request_id,
189 did,
190 device_id
191 )
192 .execute(pool)
193 .await?;
194 Ok(())
195}
196
197pub async fn update_request_scope(
198 pool: &PgPool,
199 request_id: &str,
200 scope: &str,
201) -> Result<(), OAuthError> {
202 sqlx::query!(
203 r#"
204 UPDATE oauth_authorization_request
205 SET parameters = jsonb_set(parameters, '{scope}', to_jsonb($2::text))
206 WHERE id = $1
207 "#,
208 request_id,
209 scope
210 )
211 .execute(pool)
212 .await?;
213 Ok(())
214}