use async_trait::async_trait;
use crate::Context;
use crate::Error;
use crate::model::Account;
use crate::model::AccountData;
use crate::model::DeleteAccountResponse;
use crate::model::ErrorBody;
use crate::model::ErrorsBody;
use crate::model::Plan;
pub enum AccountError {
Error400(ErrorsBody),
Error401(ErrorBody),
Error404(ErrorBody),
Error500(ErrorBody),
}
#[async_trait]
pub trait AccountClient {
async fn account_id_get(&self, account_id: &str) -> Result<Account, Error<AccountError>>;
async fn account_id_put(&self, account_id: &str, value: &AccountData) -> Result<Account, Error<AccountError>>;
async fn account_id_delete(&self, account_id: &str) -> Result<DeleteAccountResponse, Error<AccountError>>;
async fn account_id_plan_get(&self, account_id: &str) -> Result<Plan, Error<AccountError>>;
async fn post(&self, value: &AccountData) -> Result<Account, Error<AccountError>>;
}
pub struct AccountClientLive {
pub context: Context,
}
#[async_trait]
impl AccountClient for AccountClientLive {
async fn account_id_get(&self, account_id: &str) -> Result<Account, Error<AccountError>> {
let mut url = self.context.base_url.clone();
url.path_segments_mut().unwrap()
.push("v2")
.push("accounts")
.push(account_id);
let mut request = self
.context
.client
.get(url.clone());
{
tracing::info!(method="get", endpoint="/v2/accounts/{account_id}", url=url.to_string(), "account_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::<Account>().await?)
}
400 => {
let body = response.json::<ErrorsBody>().await?;
Err(Error::Item(AccountError::Error400(body)))
}
401 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error401(body)))
}
404 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error404(body)))
}
500 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error500(body)))
}
_ => Err(Error::unexpected(status, response.bytes().await?)),
}
}
async fn account_id_put(&self, account_id: &str, value: &AccountData) -> Result<Account, Error<AccountError>> {
let mut url = self.context.base_url.clone();
url.path_segments_mut().unwrap()
.push("v2")
.push("accounts")
.push(account_id);
let mut request = self
.context
.client
.put(url.clone());
{
tracing::info!(method="put", endpoint="/v2/accounts/{account_id}", url=url.to_string(), body=serde_json::to_string(value)?, "account_id_put");
}
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::<Account>().await?)
}
400 => {
let body = response.json::<ErrorsBody>().await?;
Err(Error::Item(AccountError::Error400(body)))
}
401 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error401(body)))
}
404 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error404(body)))
}
500 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error500(body)))
}
_ => Err(Error::unexpected(status, response.bytes().await?)),
}
}
async fn account_id_delete(&self, account_id: &str) -> Result<DeleteAccountResponse, Error<AccountError>> {
let mut url = self.context.base_url.clone();
url.path_segments_mut().unwrap()
.push("v2")
.push("accounts")
.push(account_id);
let mut request = self
.context
.client
.delete(url.clone());
{
tracing::info!(method="delete", endpoint="/v2/accounts/{account_id}", url=url.to_string(), "account_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::<DeleteAccountResponse>().await?)
}
400 => {
let body = response.json::<ErrorsBody>().await?;
Err(Error::Item(AccountError::Error400(body)))
}
401 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error401(body)))
}
404 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error404(body)))
}
500 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error500(body)))
}
_ => Err(Error::unexpected(status, response.bytes().await?)),
}
}
async fn account_id_plan_get(&self, account_id: &str) -> Result<Plan, Error<AccountError>> {
let mut url = self.context.base_url.clone();
url.path_segments_mut().unwrap()
.push("v2")
.push("accounts")
.push(account_id)
.push("plan");
let mut request = self
.context
.client
.get(url.clone());
{
tracing::info!(method="get", endpoint="/v2/accounts/{account_id}/plan", url=url.to_string(), "account_id_plan_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::<Plan>().await?)
}
400 => {
let body = response.json::<ErrorsBody>().await?;
Err(Error::Item(AccountError::Error400(body)))
}
401 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error401(body)))
}
404 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error404(body)))
}
500 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error500(body)))
}
_ => Err(Error::unexpected(status, response.bytes().await?)),
}
}
async fn post(&self, value: &AccountData) -> Result<Account, Error<AccountError>> {
let mut url = self.context.base_url.clone();
url.path_segments_mut().unwrap()
.push("v2")
.push("accounts");
let mut request = self
.context
.client
.post(url.clone());
{
tracing::info!(method="post", endpoint="/v2/accounts", 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::<Account>().await?)
}
400 => {
let body = response.json::<ErrorsBody>().await?;
Err(Error::Item(AccountError::Error400(body)))
}
401 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error401(body)))
}
404 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error404(body)))
}
500 => {
let body = response.json::<ErrorBody>().await?;
Err(Error::Item(AccountError::Error500(body)))
}
_ => Err(Error::unexpected(status, response.bytes().await?)),
}
}
}