1use std::{collections::HashMap, sync::Arc, time::Duration};
2
3use reqwest::multipart;
4use serde::Deserialize;
5use tokio::sync::Mutex;
6use url::Url;
7
8use crate::{
9 auth::{AuthClient, TokenSet},
10 channel::DocumentChannel,
11 error::ScribeError,
12 model::{
13 AccountInfo, BrailleTable, BrailleTablesResponse, CreatedDocument, Dialect,
14 DialectsResponse, DocumentList, DocumentListResponse, DocumentSummary, Download, Language,
15 LanguagesResponse, NotificationSettings, OutputFormat, OutputList, OutputListResponse,
16 Settings, SettingsUpdate, TrashedDocument, TrashedDocumentListResponse, Voice,
17 VoicesResponse,
18 },
19};
20
21const REFRESH_SKEW: Duration = Duration::from_secs(300);
24
25pub enum DocumentSource {
27 File { file_name: String, bytes: Vec<u8> },
29 Url(String),
31}
32
33#[derive(Debug, Deserialize)]
34struct ApiErrorResponse {
35 error: ApiErrorBody,
36}
37
38#[derive(Debug, Deserialize)]
39struct ApiErrorBody {
40 code: String,
41 #[serde(default)]
42 message: Option<String>,
43}
44
45pub const DELETE_ACCOUNT_PATH: &str = "/settings/delete_account";
56
57pub struct ScribeClient {
58 http: reqwest::Client,
59 base_url: Url,
60 auth: AuthClient,
61 tokens: Arc<Mutex<TokenSet>>,
62}
63
64impl ScribeClient {
65 pub fn new(
66 http: reqwest::Client,
67 base_url: Url,
68 client_id: impl Into<String>,
69 tokens: TokenSet,
70 ) -> Self {
71 let auth = AuthClient::new(http.clone(), base_url.clone(), client_id);
72 ScribeClient {
73 http,
74 base_url,
75 auth,
76 tokens: Arc::new(Mutex::new(tokens)),
77 }
78 }
79
80 async fn access_token(&self) -> Result<String, ScribeError> {
83 let mut tokens = self.tokens.lock().await;
84 if tokens.needs_refresh(REFRESH_SKEW) {
85 if let Some(refresh_token) = tokens.refresh_token.clone() {
86 *tokens = self.auth.refresh(&refresh_token).await?;
87 }
88 }
89 Ok(tokens.access_token.clone())
90 }
91
92 pub async fn current_tokens(&self) -> TokenSet {
95 self.tokens.lock().await.clone()
96 }
97
98 async fn force_refresh(&self) -> Result<String, ScribeError> {
102 let mut tokens = self.tokens.lock().await;
103 let refresh_token =
104 tokens
105 .refresh_token
106 .clone()
107 .ok_or_else(|| ScribeError::InvalidGrant {
108 message: "Your session has expired. Please sign in again.".to_string(),
109 })?;
110 *tokens = self.auth.refresh(&refresh_token).await?;
111 Ok(tokens.access_token.clone())
112 }
113
114 pub async fn create_document(
125 &self,
126 source: DocumentSource,
127 password: Option<&str>,
128 ) -> Result<CreatedDocument, ScribeError> {
129 let mut url = self.base_url.clone();
130 url.set_path("/api/documents");
131 self.with_auth_retry(|token| {
132 let form = match &source {
133 DocumentSource::File { file_name, bytes } => multipart::Form::new().part(
134 "document[file]",
135 multipart::Part::bytes(bytes.clone()).file_name(file_name.clone()),
136 ),
137 DocumentSource::Url(source_url) => {
138 multipart::Form::new().text("document[url]", source_url.clone())
139 }
140 };
141 let form = match password {
142 Some(password) => form.text("document[password]", password.to_string()),
143 None => form,
144 };
145 self.http
146 .post(url.clone())
147 .bearer_auth(token)
148 .multipart(form)
149 })
150 .await
151 }
152
153 pub async fn list_documents(&self) -> Result<DocumentList, ScribeError> {
162 let mut url = self.base_url.clone();
163 url.set_path("/api/documents");
164
165 let response: DocumentListResponse = self
166 .with_auth_retry(|token| self.http.get(url.clone()).bearer_auth(token))
167 .await?;
168
169 Ok(DocumentList {
170 documents: response.documents,
171 pages_remaining: response.pages_remaining,
172 })
173 }
174
175 pub async fn trash_document(&self, document_id: &str) -> Result<(), ScribeError> {
185 let mut url = self.base_url.clone();
186 url.set_path(&format!("/api/documents/{document_id}/trash"));
187 self.with_auth_retry_raw(|token| self.http.post(url.clone()).bearer_auth(token))
188 .await?;
189 Ok(())
190 }
191
192 pub async fn delete_document_permanently(&self, document_id: &str) -> Result<(), ScribeError> {
204 let mut url = self.base_url.clone();
205 url.set_path(&format!("/api/documents/{document_id}"));
206 self.with_auth_retry_raw(|token| self.http.delete(url.clone()).bearer_auth(token))
207 .await?;
208 Ok(())
209 }
210
211 pub async fn recover_document(&self, document_id: &str) -> Result<(), ScribeError> {
219 let mut url = self.base_url.clone();
220 url.set_path(&format!("/api/documents/{document_id}/recover"));
221 self.with_auth_retry_raw(|token| self.http.post(url.clone()).bearer_auth(token))
222 .await?;
223 Ok(())
224 }
225
226 pub async fn list_trashed_documents(&self) -> Result<Vec<TrashedDocument>, ScribeError> {
232 let mut url = self.base_url.clone();
233 url.set_path("/api/documents/trash");
234 let response: TrashedDocumentListResponse = self
235 .with_auth_retry(|token| self.http.get(url.clone()).bearer_auth(token))
236 .await?;
237 Ok(response.documents)
238 }
239
240 pub async fn submit_document_feedback(
243 &self,
244 document_id: &str,
245 comment: &str,
246 ) -> Result<(), ScribeError> {
247 let mut url = self.base_url.clone();
248 url.set_path(&format!("/api/documents/{document_id}/feedback"));
249 let body = serde_json::json!({ "comment": comment });
250 self.with_auth_retry_raw(|token| {
251 self.http.post(url.clone()).bearer_auth(token).json(&body)
252 })
253 .await?;
254 Ok(())
255 }
256
257 pub async fn open_document_channel(
272 &self,
273 document_id: &str,
274 ) -> Result<DocumentChannel, ScribeError> {
275 let token = self.access_token().await?;
276 match self.connect_ws_channel(document_id, &token).await {
277 Err(ScribeError::WebSocket(_)) => {
281 let token = self.force_refresh().await?;
282 self.connect_ws_channel(document_id, &token).await
283 }
284 other => other,
285 }
286 }
287
288 async fn connect_ws_channel(
289 &self,
290 document_id: &str,
291 token: &str,
292 ) -> Result<DocumentChannel, ScribeError> {
293 let mut url = self.base_url.clone();
294 let ws_scheme = if url.scheme() == "https" { "wss" } else { "ws" };
295 url.set_scheme(ws_scheme)
296 .map_err(|()| ScribeError::Channel {
297 message: "Something went wrong. Please try again.".to_string(),
298 })?;
299 url.set_path("/socket/websocket");
300 url.query_pairs_mut()
301 .append_pair("vsn", "2.0.0")
302 .append_pair("token", token);
303 let (ws, _response) = tokio_tungstenite::connect_async(url.as_str())
304 .await
305 .map_err(|e| ScribeError::WebSocket(Box::new(e)))?;
306 DocumentChannel::join(ws, document_id).await
307 }
308
309 pub async fn list_outputs(&self, document_id: &str) -> Result<OutputList, ScribeError> {
315 let mut url = self.base_url.clone();
316 url.set_path(&format!("/api/documents/{document_id}/outputs"));
317 let response: OutputListResponse = self
318 .with_auth_retry(|token| self.http.get(url.clone()).bearer_auth(token))
319 .await?;
320 Ok(OutputList {
321 outputs: response.outputs,
322 is_password_needed: response.is_password_needed,
323 })
324 }
325
326 pub async fn download_output(
333 &self,
334 document_id: &str,
335 format: OutputFormat,
336 ) -> Result<Download, ScribeError> {
337 self.download_output_with_progress(document_id, format, |_, _| {})
338 .await
339 }
340
341 pub async fn download_url(
354 &self,
355 document_id: &str,
356 format: OutputFormat,
357 ) -> Result<Option<String>, ScribeError> {
358 let mut url = self.base_url.clone();
359 url.set_path(&format!(
360 "/api/documents/{document_id}/outputs/{}/download",
361 format.as_str()
362 ));
363 let client = reqwest::Client::builder()
366 .redirect(reqwest::redirect::Policy::none())
367 .build()?;
368
369 let token = self.access_token().await?;
370 let mut response = client.get(url.clone()).bearer_auth(&token).send().await?;
371 if response.status() == reqwest::StatusCode::UNAUTHORIZED {
372 let token = self.force_refresh().await?;
373 response = client.get(url.clone()).bearer_auth(&token).send().await?;
374 }
375
376 if response.status().is_redirection() {
377 return Ok(response
378 .headers()
379 .get(reqwest::header::LOCATION)
380 .and_then(|value| value.to_str().ok())
381 .map(str::to_string));
382 }
383 response.error_for_status_or_json_error().await?;
386 Ok(None)
387 }
388
389 pub async fn download_output_with_progress<F>(
400 &self,
401 document_id: &str,
402 format: OutputFormat,
403 mut on_progress: F,
404 ) -> Result<Download, ScribeError>
405 where
406 F: FnMut(u64, Option<u64>) + Send,
407 {
408 let mut url = self.base_url.clone();
409 url.set_path(&format!(
410 "/api/documents/{document_id}/outputs/{}/download",
411 format.as_str()
412 ));
413 let mut response = self
414 .with_auth_retry_raw(|token| self.http.get(url.clone()).bearer_auth(token))
415 .await?;
416 let file_name = response
417 .headers()
418 .get(reqwest::header::CONTENT_DISPOSITION)
419 .and_then(|value| value.to_str().ok())
420 .and_then(content_disposition_file_name);
421 let total = response_total_bytes(&response);
422
423 let mut data: Vec<u8> = Vec::with_capacity(total.unwrap_or(0) as usize);
424 on_progress(0, total);
425 while let Some(chunk) = response.chunk().await? {
426 data.extend_from_slice(&chunk);
427 on_progress(data.len() as u64, total);
428 }
429 Ok(Download { data, file_name })
430 }
431
432 pub async fn get_settings(&self, document_id: &str) -> Result<Settings, ScribeError> {
438 let mut url = self.base_url.clone();
439 url.set_path(&format!("/api/documents/{document_id}/settings"));
440 self.with_auth_retry(|token| self.http.get(url.clone()).bearer_auth(token))
441 .await
442 }
443
444 pub async fn update_settings(
451 &self,
452 document_id: &str,
453 update: &SettingsUpdate,
454 ) -> Result<Settings, ScribeError> {
455 let mut url = self.base_url.clone();
456 url.set_path(&format!("/api/documents/{document_id}/settings"));
457 let body = serde_json::json!({ "settings": update });
458 self.with_auth_retry(|token| self.http.patch(url.clone()).bearer_auth(token).json(&body))
459 .await
460 }
461
462 pub async fn rename_document(
476 &self,
477 document_id: &str,
478 title: &str,
479 ) -> Result<DocumentSummary, ScribeError> {
480 let mut url = self.base_url.clone();
481 url.set_path(&format!("/api/documents/{document_id}"));
482 let body = serde_json::json!({ "document": { "title": title } });
483 self.with_auth_retry(|token| self.http.patch(url.clone()).bearer_auth(token).json(&body))
484 .await
485 }
486
487 pub async fn browser_entry_url(&self, return_to_path: &str) -> Result<String, ScribeError> {
504 let token = self.access_token().await?;
505 let state = serde_json::json!({ "return_to": return_to_path }).to_string();
506 let mut url = self.base_url.clone();
507 url.set_path("/auth/browser_from_oauth");
508 url.query_pairs_mut()
509 .append_pair("token", &token)
510 .append_pair("state", &state);
511 Ok(url.into())
512 }
513
514 pub async fn delete_account_url(&self) -> Result<String, ScribeError> {
521 self.browser_entry_url(DELETE_ACCOUNT_PATH).await
522 }
523
524 pub async fn default_settings(&self) -> Result<Settings, ScribeError> {
534 let mut url = self.base_url.clone();
535 url.set_path("/api/document_settings");
536 self.with_auth_retry(|token| self.http.get(url.clone()).bearer_auth(token))
537 .await
538 }
539
540 pub async fn update_default_settings(
550 &self,
551 update: &SettingsUpdate,
552 ) -> Result<Settings, ScribeError> {
553 let mut url = self.base_url.clone();
554 url.set_path("/api/document_settings");
555 let body = serde_json::json!({ "settings": update });
556 self.with_auth_retry(|token| self.http.patch(url.clone()).bearer_auth(token).json(&body))
557 .await
558 }
559
560 pub async fn register_device(&self, token: &str, platform: &str) -> Result<(), ScribeError> {
569 let mut url = self.base_url.clone();
570 url.set_path("/api/devices");
571 let body = serde_json::json!({ "token": token, "platform": platform });
572 self.with_auth_retry_raw(|token| {
573 self.http.post(url.clone()).bearer_auth(token).json(&body)
574 })
575 .await?;
576 Ok(())
577 }
578
579 pub async fn unregister_device(&self, token: &str) -> Result<(), ScribeError> {
585 let mut url = self.base_url.clone();
586 url.set_path(&format!("/api/devices/{token}"));
587 self.with_auth_retry_raw(|t| self.http.delete(url.clone()).bearer_auth(t))
588 .await?;
589 Ok(())
590 }
591
592 pub async fn get_notification_settings(&self) -> Result<NotificationSettings, ScribeError> {
596 let mut url = self.base_url.clone();
597 url.set_path("/api/notification_settings");
598 self.with_auth_retry(|token| self.http.get(url.clone()).bearer_auth(token))
599 .await
600 }
601
602 pub async fn update_notification_settings(
606 &self,
607 push_notify_when_complete: bool,
608 ) -> Result<NotificationSettings, ScribeError> {
609 let mut url = self.base_url.clone();
610 url.set_path("/api/notification_settings");
611 let body = serde_json::json!({ "push_notify_when_complete": push_notify_when_complete });
612 self.with_auth_retry(|token| self.http.patch(url.clone()).bearer_auth(token).json(&body))
613 .await
614 }
615
616 pub async fn get_account_info(&self) -> Result<AccountInfo, ScribeError> {
620 let mut url = self.base_url.clone();
621 url.set_path("/api/account_info");
622 self.with_auth_retry(|token| self.http.get(url.clone()).bearer_auth(token))
623 .await
624 }
625
626 pub async fn languages(&self) -> Result<Vec<Language>, ScribeError> {
630 let mut url = self.base_url.clone();
631 url.set_path("/api/settings/languages");
632 let response: LanguagesResponse = self
633 .with_auth_retry(|token| self.http.get(url.clone()).bearer_auth(token))
634 .await?;
635 Ok(response.languages)
636 }
637
638 pub async fn dialects(&self) -> Result<HashMap<String, Vec<Dialect>>, ScribeError> {
642 let mut url = self.base_url.clone();
643 url.set_path("/api/settings/dialects");
644 let response: DialectsResponse = self
645 .with_auth_retry(|token| self.http.get(url.clone()).bearer_auth(token))
646 .await?;
647 Ok(response.dialects)
648 }
649
650 pub async fn braille_tables(&self) -> Result<Vec<BrailleTable>, ScribeError> {
654 let mut url = self.base_url.clone();
655 url.set_path("/api/settings/braille_tables");
656 let response: BrailleTablesResponse = self
657 .with_auth_retry(|token| self.http.get(url.clone()).bearer_auth(token))
658 .await?;
659 Ok(response.braille_tables)
660 }
661
662 pub async fn voices(&self) -> Result<HashMap<String, Vec<Voice>>, ScribeError> {
666 let mut url = self.base_url.clone();
667 url.set_path("/api/settings/voices");
668 let response: VoicesResponse = self
669 .with_auth_retry(|token| self.http.get(url.clone()).bearer_auth(token))
670 .await?;
671 Ok(response.voices)
672 }
673
674 async fn with_auth_retry_raw<F>(&self, build: F) -> Result<reqwest::Response, ScribeError>
678 where
679 F: Fn(&str) -> reqwest::RequestBuilder,
680 {
681 let token = self.access_token().await?;
682 let response = build(&token).send().await?;
683 let response = if response.status() == reqwest::StatusCode::UNAUTHORIZED {
684 let token = self.force_refresh().await?;
685 build(&token).send().await?
686 } else {
687 response
688 };
689 response.error_for_status_or_json_error().await
690 }
691
692 async fn with_auth_retry<T, F>(&self, build: F) -> Result<T, ScribeError>
694 where
695 T: serde::de::DeserializeOwned,
696 F: Fn(&str) -> reqwest::RequestBuilder,
697 {
698 self.with_auth_retry_raw(build)
699 .await?
700 .json()
701 .await
702 .map_err(Into::into)
703 }
704}
705
706fn response_total_bytes(response: &reqwest::Response) -> Option<u64> {
713 response.content_length().or_else(|| {
714 response
715 .headers()
716 .get("x-scribe-content-length")
717 .and_then(|value| value.to_str().ok())
718 .and_then(|value| value.trim().parse().ok())
719 })
720}
721
722fn content_disposition_file_name(header: &str) -> Option<String> {
727 let mut fallback = None;
728 let mut extended = None;
729 for param in header.split(';').map(str::trim) {
730 if let Some(value) = param.strip_prefix("filename*=") {
731 let mut parts = value.splitn(3, '\'');
735 if let (Some(charset), Some(_), Some(encoded)) =
736 (parts.next(), parts.next(), parts.next())
737 {
738 if charset.eq_ignore_ascii_case("utf-8") {
739 extended = percent_encoding::percent_decode_str(encoded)
740 .decode_utf8()
741 .ok()
742 .map(|name| name.into_owned());
743 }
744 }
745 } else if let Some(value) = param.strip_prefix("filename=") {
746 fallback = Some(value.trim_matches('"').to_string());
747 }
748 }
749 extended
750 .or(fallback)
751 .and_then(|name| name.rsplit(['/', '\\']).next().map(str::to_string))
752 .filter(|name| !name.is_empty())
753}
754
755trait ResponseExt {
756 async fn error_for_status_or_json_error(self) -> Result<reqwest::Response, ScribeError>;
757}
758
759impl ResponseExt for reqwest::Response {
760 async fn error_for_status_or_json_error(self) -> Result<reqwest::Response, ScribeError> {
761 let status = self.status();
762 if status.is_success() {
763 return Ok(self);
764 }
765 let text = self.text().await.unwrap_or_default();
766 let Ok(body) = serde_json::from_str::<ApiErrorResponse>(&text) else {
770 return Err(ScribeError::Api {
771 status: status.as_u16(),
772 code: "server_error".to_string(),
773 message: "Something went wrong. Please try again.".to_string(),
774 });
775 };
776 let message = body
777 .error
778 .message
779 .unwrap_or_else(|| "Something went wrong. Please try again.".to_string());
780 Err(match body.error.code.as_str() {
781 "not_found" => ScribeError::NotFound { message },
782 "forbidden" => ScribeError::Forbidden { message },
783 "not_trashed" => ScribeError::NotTrashed { message },
784 "conversion_not_complete" => ScribeError::ConversionNotComplete { message },
785 _ => ScribeError::Api {
786 status: status.as_u16(),
787 code: body.error.code,
788 message,
789 },
790 })
791 }
792}