use async_trait::async_trait;
use crate::Context;
use crate::Error;
use crate::model::CreateTokenDto;
use crate::model::DeleteTokenResponse;
use crate::model::ErrorBody;
use crate::model::ErrorsBody;
use crate::model::Token;
use crate::model::UnsafeToken;
use uuid::Uuid;
pub enum TokenError {
Error400(ErrorsBody),
Error401(ErrorBody),
Error404(ErrorBody),
Error500(ErrorBody),
}
#[async_trait]
pub trait TokenClient {
async fn get(&self, account_id: &str) -> Result<Vec<Token>, Error<TokenError>>;
async fn post(&self, account_id: &str, value: &CreateTokenDto) -> Result<UnsafeToken, Error<TokenError>>;
async fn token_id_get(&self, account_id: &str, token_id: &Uuid) -> Result<Token, Error<TokenError>>;
async fn token_id_delete(&self, account_id: &str, token_id: &Uuid) -> Result<DeleteTokenResponse, Error<TokenError>>;
}
pub struct TokenClientLive {
pub context: Context,
}
#[async_trait]
impl TokenClient for TokenClientLive {
async fn get(&self, account_id: &str) -> Result<Vec<Token>, Error<TokenError>> {
let mut url = self.context.base_url.clone();
url.path_segments_mut().unwrap()
.push("v2")
.push("accounts")
.push(account_id)
.push("tokens");
let mut request = self
.context
.client
.get(url.clone());
{
tracing::info!(method="get", endpoint="/v2/accounts/{account_id}/tokens", url=url.to_string(), "get");
}
if let Some(token) = self.context.bearer_token() {
request = request.bearer_auth(token);
}
let response = request.send().await?;
let status = response.status().as_u16();
match status {
200 => {
Ok(response.json::<Vec<Token>>().await?)
}
400 => {
let body = response.json::<ErrorsBody>().await?;
Err(Error::Item(TokenError::Error400(body)))
}
401 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error401(body)))
}
404 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error404(body)))
}
500 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error500(body)))
}
_ => Err(Error::unexpected(status, response.bytes().await?)),
}
}
async fn post(&self, account_id: &str, value: &CreateTokenDto) -> Result<UnsafeToken, Error<TokenError>> {
let mut url = self.context.base_url.clone();
url.path_segments_mut().unwrap()
.push("v2")
.push("accounts")
.push(account_id)
.push("tokens");
let mut request = self
.context
.client
.post(url.clone());
{
tracing::info!(method="post", endpoint="/v2/accounts/{account_id}/tokens", url=url.to_string(), body=serde_json::to_string(value)?, "post");
}
if let Some(token) = self.context.bearer_token() {
request = request.bearer_auth(token);
}
request = request.json(value);
let response = request.send().await?;
let status = response.status().as_u16();
match status {
200 => {
Ok(response.json::<UnsafeToken>().await?)
}
400 => {
let body = response.json::<ErrorsBody>().await?;
Err(Error::Item(TokenError::Error400(body)))
}
401 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error401(body)))
}
404 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error404(body)))
}
500 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error500(body)))
}
_ => Err(Error::unexpected(status, response.bytes().await?)),
}
}
async fn token_id_get(&self, account_id: &str, token_id: &Uuid) -> Result<Token, Error<TokenError>> {
let mut url = self.context.base_url.clone();
url.path_segments_mut().unwrap()
.push("v2")
.push("accounts")
.push(account_id)
.push("tokens")
.push(&token_id.to_string());
let mut request = self
.context
.client
.get(url.clone());
{
tracing::info!(method="get", endpoint="/v2/accounts/{account_id}/tokens/{token_id}", url=url.to_string(), "token_id_get");
}
if let Some(token) = self.context.bearer_token() {
request = request.bearer_auth(token);
}
let response = request.send().await?;
let status = response.status().as_u16();
match status {
200 => {
Ok(response.json::<Token>().await?)
}
400 => {
let body = response.json::<ErrorsBody>().await?;
Err(Error::Item(TokenError::Error400(body)))
}
401 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error401(body)))
}
404 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error404(body)))
}
500 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error500(body)))
}
_ => Err(Error::unexpected(status, response.bytes().await?)),
}
}
async fn token_id_delete(&self, account_id: &str, token_id: &Uuid) -> Result<DeleteTokenResponse, Error<TokenError>> {
let mut url = self.context.base_url.clone();
url.path_segments_mut().unwrap()
.push("v2")
.push("accounts")
.push(account_id)
.push("tokens")
.push(&token_id.to_string());
let mut request = self
.context
.client
.delete(url.clone());
{
tracing::info!(method="delete", endpoint="/v2/accounts/{account_id}/tokens/{token_id}", url=url.to_string(), "token_id_delete");
}
if let Some(token) = self.context.bearer_token() {
request = request.bearer_auth(token);
}
let response = request.send().await?;
let status = response.status().as_u16();
match status {
200 => {
Ok(response.json::<DeleteTokenResponse>().await?)
}
400 => {
let body = response.json::<ErrorsBody>().await?;
Err(Error::Item(TokenError::Error400(body)))
}
401 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error401(body)))
}
404 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error404(body)))
}
500 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(TokenError::Error500(body)))
}
_ => Err(Error::unexpected(status, response.bytes().await?)),
}
}
}