134 lines
4.7 KiB
Rust
134 lines
4.7 KiB
Rust
use reqwest::Url;
|
|
use reqwest_middleware::ClientWithMiddleware;
|
|
use serde::de::DeserializeOwned;
|
|
use thiserror::Error;
|
|
use tracing::instrument;
|
|
use crate::models::{AccountArray, TransactionStore, TransactionArray, TransactionUpdate};
|
|
|
|
#[derive(Error, Debug)]
|
|
pub enum FireflyError {
|
|
#[error("Request failed: {0}")]
|
|
RequestFailed(#[from] reqwest::Error),
|
|
#[error("Middleware error: {0}")]
|
|
MiddlewareError(#[from] reqwest_middleware::Error),
|
|
#[error("API Error: {0}")]
|
|
ApiError(String),
|
|
#[error("URL Parse Error: {0}")]
|
|
UrlParseError(#[from] url::ParseError),
|
|
}
|
|
|
|
pub struct FireflyClient {
|
|
base_url: Url,
|
|
client: ClientWithMiddleware,
|
|
access_token: String,
|
|
}
|
|
|
|
impl FireflyClient {
|
|
pub fn new(base_url: &str, access_token: &str) -> Result<Self, FireflyError> {
|
|
Self::with_client(base_url, access_token, None)
|
|
}
|
|
|
|
pub fn with_client(base_url: &str, access_token: &str, client: Option<ClientWithMiddleware>) -> Result<Self, FireflyError> {
|
|
Ok(Self {
|
|
base_url: Url::parse(base_url)?,
|
|
client: client.unwrap_or_else(|| reqwest_middleware::ClientBuilder::new(reqwest::Client::new()).build()),
|
|
access_token: access_token.to_string(),
|
|
})
|
|
}
|
|
|
|
#[instrument(skip(self))]
|
|
pub async fn get_accounts(&self, _iban: &str) -> Result<AccountArray, FireflyError> {
|
|
let mut url = self.base_url.join("/api/v1/accounts")?;
|
|
url.query_pairs_mut()
|
|
.append_pair("type", "asset");
|
|
|
|
self.get_authenticated(url).await
|
|
}
|
|
|
|
#[instrument(skip(self))]
|
|
pub async fn search_accounts(&self, query: &str) -> Result<AccountArray, FireflyError> {
|
|
let mut url = self.base_url.join("/api/v1/search/accounts")?;
|
|
url.query_pairs_mut()
|
|
.append_pair("query", query)
|
|
.append_pair("type", "asset")
|
|
.append_pair("field", "all");
|
|
|
|
self.get_authenticated(url).await
|
|
}
|
|
|
|
#[instrument(skip(self, transaction))]
|
|
pub async fn store_transaction(&self, transaction: TransactionStore) -> Result<(), FireflyError> {
|
|
let url = self.base_url.join("/api/v1/transactions")?;
|
|
|
|
let response = self.client.post(url)
|
|
.bearer_auth(&self.access_token)
|
|
.header("accept", "application/json")
|
|
.json(&transaction)
|
|
.send()
|
|
.await?;
|
|
|
|
if !response.status().is_success() {
|
|
let status = response.status();
|
|
let text = response.text().await?;
|
|
return Err(FireflyError::ApiError(format!("Store Transaction Failed {}: {}", status, text)));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[instrument(skip(self))]
|
|
pub async fn list_account_transactions(&self, account_id: &str, start: Option<&str>, end: Option<&str>) -> Result<TransactionArray, FireflyError> {
|
|
let mut url = self.base_url.join(&format!("/api/v1/accounts/{}/transactions", account_id))?;
|
|
{
|
|
let mut pairs = url.query_pairs_mut();
|
|
if let Some(s) = start {
|
|
pairs.append_pair("start", s);
|
|
}
|
|
if let Some(e) = end {
|
|
pairs.append_pair("end", e);
|
|
}
|
|
// Limit to 50, could be higher but safer to page if needed. For heuristic checks 50 is usually plenty per day range.
|
|
pairs.append_pair("limit", "50");
|
|
}
|
|
|
|
self.get_authenticated(url).await
|
|
}
|
|
|
|
#[instrument(skip(self, update))]
|
|
pub async fn update_transaction(&self, id: &str, update: TransactionUpdate) -> Result<(), FireflyError> {
|
|
let url = self.base_url.join(&format!("/api/v1/transactions/{}", id))?;
|
|
|
|
let response = self.client.put(url)
|
|
.bearer_auth(&self.access_token)
|
|
.header("accept", "application/json")
|
|
.json(&update)
|
|
.send()
|
|
.await?;
|
|
|
|
if !response.status().is_success() {
|
|
let status = response.status();
|
|
let text = response.text().await?;
|
|
return Err(FireflyError::ApiError(format!("Update Transaction Failed {}: {}", status, text)));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn get_authenticated<T: DeserializeOwned>(&self, url: Url) -> Result<T, FireflyError> {
|
|
let response = self.client.get(url)
|
|
.bearer_auth(&self.access_token)
|
|
.header("accept", "application/json")
|
|
.send()
|
|
.await?;
|
|
|
|
if !response.status().is_success() {
|
|
let status = response.status();
|
|
let text = response.text().await?;
|
|
return Err(FireflyError::ApiError(format!("API request failed {}: {}", status, text)));
|
|
}
|
|
|
|
let data = response.json().await?;
|
|
Ok(data)
|
|
}
|
|
}
|