#[derive(Debug)]
pub enum AccountError {
RequestFailure(reqwest::Error),
InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
UnexpectedStatus(reqwest::StatusCode),
Status401 {
message: String,
},
Status404 {
message: String,
},
Status400 {
errors: Vec<String>,
},
Status500 {
error: String,
},
}
impl From<reqwest::Error> for AccountError {
fn from(error: reqwest::Error) -> AccountError {
AccountError::RequestFailure(error)
}
}
impl From<reqwest::header::InvalidHeaderValue> for AccountError {
fn from(error: reqwest::header::InvalidHeaderValue) -> AccountError {
AccountError::InvalidHeaderValue(error)
}
}
impl AccountError {
pub fn to_account_endpoint_error(&self) -> Option<crate::model::AccountEndpointError> {
match self {
AccountError::Status401 { message } => Some(crate::model::AccountEndpointError::Unauthorized { message: message.clone() }),
AccountError::Status404 { message } => Some(crate::model::AccountEndpointError::NotFound { message: message.clone() }),
AccountError::Status400 { errors } => Some(crate::model::AccountEndpointError::ArgValidation { errors: errors.clone() }),
AccountError::Status500 { error } => Some(crate::model::AccountEndpointError::Internal { error: error.clone() }),
_ => None
}
}
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct AccountEndpointErrorUnauthorizedPayload {
pub message: String,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct AccountEndpointErrorNotFoundPayload {
pub message: String,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct AccountEndpointErrorArgValidationPayload {
pub errors: Vec<String>,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct AccountEndpointErrorInternalPayload {
pub error: String,
}
#[async_trait::async_trait]
pub trait Account {
async fn get_account(&self, account_id: &str, authorization: &str) -> Result<crate::model::Account, AccountError>;
async fn get_account_plan(&self, account_id: &str, authorization: &str) -> Result<crate::model::Plan, AccountError>;
async fn put_account(&self, account_id: &str, field0: crate::model::AccountData, authorization: &str) -> Result<crate::model::Account, AccountError>;
async fn post_account(&self, field0: crate::model::AccountData, authorization: &str) -> Result<crate::model::Account, AccountError>;
async fn delete_account(&self, account_id: &str, authorization: &str) -> Result<(), AccountError>;
}
#[derive(Clone, Debug)]
pub struct AccountLive {
pub base_url: reqwest::Url,
pub allow_insecure: bool,
}
#[async_trait::async_trait]
impl Account for AccountLive {
async fn get_account(&self, account_id: &str, authorization: &str) -> Result<crate::model::Account, AccountError> {
let mut url = self.base_url.clone();
url.path_segments_mut().unwrap()
.push("v1")
.push("accounts")
.push(account_id);
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
{
let headers_vec: Vec<(&str, String)> = headers.iter().map(|(k, v)| crate::hide_authorization(k, v)).collect();
tracing::info!(method="get", url=url.to_string(), headers=?headers_vec, body="<no_body>", "get_account");
}
let mut builder = reqwest::Client::builder();
if self.allow_insecure {
builder = builder.danger_accept_invalid_certs(true);
}
let client = builder.build()?;
let result = client
.get(url)
.headers(headers)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = result.json::<crate::model::Account>().await?;
Ok(body)
}
401 => {
let body = result.json::<AccountEndpointErrorUnauthorizedPayload>().await?;
Err(AccountError::Status401 { message: body.message })
}
404 => {
let body = result.json::<AccountEndpointErrorNotFoundPayload>().await?;
Err(AccountError::Status404 { message: body.message })
}
400 => {
let body = result.json::<AccountEndpointErrorArgValidationPayload>().await?;
Err(AccountError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<AccountEndpointErrorInternalPayload>().await?;
Err(AccountError::Status500 { error: body.error })
}
_ => Err(AccountError::UnexpectedStatus(result.status()))
}
}
async fn get_account_plan(&self, account_id: &str, authorization: &str) -> Result<crate::model::Plan, AccountError> {
let mut url = self.base_url.clone();
url.path_segments_mut().unwrap()
.push("v1")
.push("accounts")
.push(account_id)
.push("plan");
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
{
let headers_vec: Vec<(&str, String)> = headers.iter().map(|(k, v)| crate::hide_authorization(k, v)).collect();
tracing::info!(method="get", url=url.to_string(), headers=?headers_vec, body="<no_body>", "get_account_plan");
}
let mut builder = reqwest::Client::builder();
if self.allow_insecure {
builder = builder.danger_accept_invalid_certs(true);
}
let client = builder.build()?;
let result = client
.get(url)
.headers(headers)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = result.json::<crate::model::Plan>().await?;
Ok(body)
}
401 => {
let body = result.json::<AccountEndpointErrorUnauthorizedPayload>().await?;
Err(AccountError::Status401 { message: body.message })
}
404 => {
let body = result.json::<AccountEndpointErrorNotFoundPayload>().await?;
Err(AccountError::Status404 { message: body.message })
}
400 => {
let body = result.json::<AccountEndpointErrorArgValidationPayload>().await?;
Err(AccountError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<AccountEndpointErrorInternalPayload>().await?;
Err(AccountError::Status500 { error: body.error })
}
_ => Err(AccountError::UnexpectedStatus(result.status()))
}
}
async fn put_account(&self, account_id: &str, field0: crate::model::AccountData, authorization: &str) -> Result<crate::model::Account, AccountError> {
let mut url = self.base_url.clone();
url.path_segments_mut().unwrap()
.push("v1")
.push("accounts")
.push(account_id);
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
{
let headers_vec: Vec<(&str, String)> = headers.iter().map(|(k, v)| crate::hide_authorization(k, v)).collect();
tracing::info!(method="put", url=url.to_string(), headers=?headers_vec, body=serde_json::to_string(&field0).unwrap(), "put_account");
}
let mut builder = reqwest::Client::builder();
if self.allow_insecure {
builder = builder.danger_accept_invalid_certs(true);
}
let client = builder.build()?;
let result = client
.put(url)
.headers(headers)
.json(&field0)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = result.json::<crate::model::Account>().await?;
Ok(body)
}
401 => {
let body = result.json::<AccountEndpointErrorUnauthorizedPayload>().await?;
Err(AccountError::Status401 { message: body.message })
}
404 => {
let body = result.json::<AccountEndpointErrorNotFoundPayload>().await?;
Err(AccountError::Status404 { message: body.message })
}
400 => {
let body = result.json::<AccountEndpointErrorArgValidationPayload>().await?;
Err(AccountError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<AccountEndpointErrorInternalPayload>().await?;
Err(AccountError::Status500 { error: body.error })
}
_ => Err(AccountError::UnexpectedStatus(result.status()))
}
}
async fn post_account(&self, field0: crate::model::AccountData, authorization: &str) -> Result<crate::model::Account, AccountError> {
let mut url = self.base_url.clone();
url.path_segments_mut().unwrap()
.push("v1")
.push("accounts");
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
{
let headers_vec: Vec<(&str, String)> = headers.iter().map(|(k, v)| crate::hide_authorization(k, v)).collect();
tracing::info!(method="post", url=url.to_string(), headers=?headers_vec, body=serde_json::to_string(&field0).unwrap(), "post_account");
}
let mut builder = reqwest::Client::builder();
if self.allow_insecure {
builder = builder.danger_accept_invalid_certs(true);
}
let client = builder.build()?;
let result = client
.post(url)
.headers(headers)
.json(&field0)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = result.json::<crate::model::Account>().await?;
Ok(body)
}
401 => {
let body = result.json::<AccountEndpointErrorUnauthorizedPayload>().await?;
Err(AccountError::Status401 { message: body.message })
}
404 => {
let body = result.json::<AccountEndpointErrorNotFoundPayload>().await?;
Err(AccountError::Status404 { message: body.message })
}
400 => {
let body = result.json::<AccountEndpointErrorArgValidationPayload>().await?;
Err(AccountError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<AccountEndpointErrorInternalPayload>().await?;
Err(AccountError::Status500 { error: body.error })
}
_ => Err(AccountError::UnexpectedStatus(result.status()))
}
}
async fn delete_account(&self, account_id: &str, authorization: &str) -> Result<(), AccountError> {
let mut url = self.base_url.clone();
url.path_segments_mut().unwrap()
.push("v1")
.push("accounts")
.push(account_id);
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
{
let headers_vec: Vec<(&str, String)> = headers.iter().map(|(k, v)| crate::hide_authorization(k, v)).collect();
tracing::info!(method="delete", url=url.to_string(), headers=?headers_vec, body="<no_body>", "delete_account");
}
let mut builder = reqwest::Client::builder();
if self.allow_insecure {
builder = builder.danger_accept_invalid_certs(true);
}
let client = builder.build()?;
let result = client
.delete(url)
.headers(headers)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = ();
Ok(body)
}
401 => {
let body = result.json::<AccountEndpointErrorUnauthorizedPayload>().await?;
Err(AccountError::Status401 { message: body.message })
}
404 => {
let body = result.json::<AccountEndpointErrorNotFoundPayload>().await?;
Err(AccountError::Status404 { message: body.message })
}
400 => {
let body = result.json::<AccountEndpointErrorArgValidationPayload>().await?;
Err(AccountError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<AccountEndpointErrorInternalPayload>().await?;
Err(AccountError::Status500 { error: body.error })
}
_ => Err(AccountError::UnexpectedStatus(result.status()))
}
}
}