taler-rust

api.rs (4958B)

---

 /*
   This file is part of TALER
   Copyright (C) 2025, 2026 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use std::borrow::Cow;
 
 use http_client::{
     ApiErr, Client, ClientErr, Ctx,
     builder::{Req, Res},
     headers::HeaderParser as _,
 };
 use hyper::{Method, StatusCode, header};
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use thiserror::Error;
 use tracing::Level;
 use url::Url;
 
 use crate::magnet_api::oauth::{Token, oauth};
 
 #[derive(Deserialize, Debug)]
 struct Header {
     #[serde(rename = "errorCode")]
     pub error_code: Option<u16>,
 }
 
 #[derive(Deserialize, Debug)]
 struct Empty {}
 
 #[derive(Deserialize, Error, Debug)]
 #[error("{error_code} {short_message} '{long_message}'")]
 pub struct MagnetError {
     #[serde(rename = "errorCode")]
     pub error_code: u16,
     #[serde(rename = "shortMessage")]
     pub short_message: String,
     #[serde(rename = "longMessage")]
     pub long_message: String,
 }
 
 #[derive(Error, Debug)]
 pub enum MagnetErr {
     #[error("magnet {0}")]
     Magnet(#[from] MagnetError),
     #[error("status {0}")]
     Status(StatusCode),
     #[error("status {0} '{1}'")]
     StatusCause(StatusCode, String),
     #[error(transparent)]
     Client(#[from] ClientErr),
 }
 pub type ApiResult<R> = std::result::Result<R, ApiErr<MagnetErr>>;
 
 /** Handle error from magnet API calls */
 async fn error_handling(res: Res) -> Result<Res, MagnetErr> {
     let status = res.status();
     match status {
         StatusCode::OK => Ok(res),
         StatusCode::BAD_REQUEST => Err(MagnetErr::Status(status)),
         StatusCode::FORBIDDEN => {
             let cause = res.str_header(header::WWW_AUTHENTICATE)?;
             Err(MagnetErr::StatusCause(status, cause))
         }
         _ => {
             if tracing::enabled!(Level::DEBUG) {
                 let body = res.text().await;
                 tracing::debug!("unexpected error body: {:?}", body);
             }
             Err(MagnetErr::Status(status))
         }
     }
 }
 
 /** Parse JSON and track error path */
 fn parse<'de, T: Deserialize<'de>>(str: &'de str) -> Result<T, MagnetErr> {
     let deserializer = &mut serde_json::Deserializer::from_str(str);
     serde_path_to_error::deserialize(deserializer)
         .map_err(|e| MagnetErr::Client(ClientErr::ResJson(e)))
 }
 
 pub struct MagnetRequest<'a> {
     req: Req,
     consumer: &'a Token,
     access: Option<&'a Token>,
     verifier: Option<&'a str>,
 }
 
 impl<'a> MagnetRequest<'a> {
     pub fn new(
         client: &Client,
         method: Method,
         base_url: &Url,
         path: impl Into<Cow<'static, str>>,
         consumer: &'a Token,
         access: Option<&'a Token>,
         verifier: Option<&'a str>,
     ) -> Self {
         Self {
             req: Req::new(client, method, base_url, path),
             consumer,
             access,
             verifier,
         }
     }
 
     pub fn query<T: Serialize>(mut self, name: &str, value: T) -> Self {
         self.req = self.req.query(name, value);
         self
     }
 
     pub fn json<T: Serialize + ?Sized>(mut self, json: &T) -> Self {
         self.req = self.req.json(json);
         self
     }
 
     async fn send(self) -> ApiResult<(Ctx, Res)> {
         let Self {
             req,
             consumer,
             access,
             verifier,
         } = self;
         oauth(req, consumer, access, verifier)
             .send()
             .await
             .map_err(|(ctx, e)| ctx.wrap(e.into()))
     }
 
     pub async fn parse_url<T: DeserializeOwned>(self) -> ApiResult<T> {
         let (ctx, res) = self.send().await?;
         async { Ok(error_handling(res).await?.urlencoded().await?) }
             .await
             .map_err(|e| ctx.wrap(e))
     }
 
     pub async fn parse_json<T: DeserializeOwned>(self) -> ApiResult<T> {
         let (ctx, res) = self.send().await?;
         async {
             let res = error_handling(res).await?;
             let raw: Box<serde_json::value::RawValue> = res.json().await?;
             let header: Header = parse(raw.get())?;
             if header.error_code.unwrap_or(200) == 200 {
                 Ok(parse(raw.get())?)
             } else {
                 Err(MagnetErr::Magnet(parse(raw.get())?))
             }
         }
         .await
         .map_err(|e| ctx.wrap(e))
     }
 
     pub async fn parse_empty(self) -> ApiResult<()> {
         self.parse_json::<Empty>().await?;
         Ok(())
     }
 }