pyrite/torn-api.rs
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

changed executor typings

Browse source
This commit is contained in:
TotallyNot 2023-02-27 00:14:37 +01:00
parent ddfbc0f7e8
commit 197b30d76b
7 changed files with 106 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
torn-api/Cargo.toml
View file

@ -1,6 +1,6 @@
[package] [package]
name = "torn-api" name = "torn-api"
version = "0.5.9" version = "0.5.10"
edition = "2021" edition = "2021"
authors = ["Pyrit [2111649]"] authors = ["Pyrit [2111649]"]
license = "MIT" license = "MIT"

18
torn-api/src/lib.rs
View file

@ -96,7 +96,7 @@ impl ApiResponse {
} }
} }
pub trait ApiSelection { pub trait ApiSelection: Send + Sync {
fn raw_value(&self) -> &'static str; fn raw_value(&self) -> &'static str;
fn category() -> &'static str; fn category() -> &'static str;
@ -137,7 +137,7 @@ where
#[derive(Debug)] #[derive(Debug)]
pub struct ApiRequest<A> pub struct ApiRequest<A>
where where
A: ApiCategoryResponse, A: ApiSelection,
{ {
pub selections: Vec<&'static str>, pub selections: Vec<&'static str>,
pub from: Option<DateTime<Utc>>, pub from: Option<DateTime<Utc>>,
@ -148,7 +148,7 @@ where
impl<A> std::default::Default for ApiRequest<A> impl<A> std::default::Default for ApiRequest<A>
where where
A: ApiCategoryResponse, A: ApiSelection,
{ {
fn default() -> Self { fn default() -> Self {
Self { Self {
@ -163,10 +163,10 @@ where
impl<A> ApiRequest<A> impl<A> ApiRequest<A>
where where
A: ApiCategoryResponse, A: ApiSelection,
{ {
pub fn url(&self, key: &str, id: Option<&str>) -> String { pub fn url(&self, key: &str, id: Option<&str>) -> String {
let mut url = format!("https://api.torn.com/{}/", A::Selection::category()); let mut url = format!("https://api.torn.com/{}/", A::category());
if let Some(id) = id { if let Some(id) = id {
write!(url, "{}", id).unwrap(); write!(url, "{}", id).unwrap();
@ -192,7 +192,7 @@ where
pub struct ApiRequestBuilder<A> pub struct ApiRequestBuilder<A>
where where
A: ApiCategoryResponse, A: ApiSelection,
{ {
request: ApiRequest<A>, request: ApiRequest<A>,
id: Option<String>, id: Option<String>,
@ -200,7 +200,7 @@ where
impl<A> Default for ApiRequestBuilder<A> impl<A> Default for ApiRequestBuilder<A>
where where
A: ApiCategoryResponse, A: ApiSelection,
{ {
fn default() -> Self { fn default() -> Self {
Self { Self {
@ -212,10 +212,10 @@ where
impl<A> ApiRequestBuilder<A> impl<A> ApiRequestBuilder<A>
where where
A: ApiCategoryResponse, A: ApiSelection,
{ {
#[must_use] #[must_use]
pub fn selections(mut self, selections: &[A::Selection]) -> Self { pub fn selections(mut self, selections: &[A]) -> Self {
self.request self.request
.selections .selections
.append(&mut selections.iter().map(ApiSelection::raw_value).collect()); .append(&mut selections.iter().map(ApiSelection::raw_value).collect());

67
torn-api/src/local.rs
View file

@ -2,7 +2,9 @@ use std::collections::HashMap;
use async_trait::async_trait; use async_trait::async_trait;
use crate::{ApiCategoryResponse, ApiClientError, ApiRequest, ApiResponse, DirectExecutor}; use crate::{
ApiCategoryResponse, ApiClientError, ApiRequest, ApiResponse, ApiSelection, DirectExecutor,
};
pub struct ApiProvider<'a, C, E> pub struct ApiProvider<'a, C, E>
where where
@ -28,8 +30,8 @@ where
pub async fn user<F>(&self, build: F) -> Result<crate::user::Response, E::Error> pub async fn user<F>(&self, build: F) -> Result<crate::user::Response, E::Error>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::user::Response>, crate::ApiRequestBuilder<crate::user::Selection>,
) -> crate::ApiRequestBuilder<crate::user::Response>, ) -> crate::ApiRequestBuilder<crate::user::Selection>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
@ -37,6 +39,7 @@ where
self.executor self.executor
.execute(self.client, builder.request, builder.id) .execute(self.client, builder.request, builder.id)
.await .await
.map(crate::user::Response::from_response)
} }
#[cfg(feature = "user")] #[cfg(feature = "user")]
@ -47,8 +50,8 @@ where
) -> HashMap<I, Result<crate::user::Response, E::Error>> ) -> HashMap<I, Result<crate::user::Response, E::Error>>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::user::Response>, crate::ApiRequestBuilder<crate::user::Selection>,
) -> crate::ApiRequestBuilder<crate::user::Response>, ) -> crate::ApiRequestBuilder<crate::user::Selection>,
I: ToString + std::hash::Hash + std::cmp::Eq, I: ToString + std::hash::Hash + std::cmp::Eq,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
@ -58,14 +61,17 @@ where
self.executor self.executor
.execute_many(self.client, builder.request, Vec::from_iter(ids)) .execute_many(self.client, builder.request, Vec::from_iter(ids))
.await .await
.into_iter()
.map(|(k, v)| (k, v.map(crate::user::Response::from_response)))
.collect()
} }
#[cfg(feature = "faction")] #[cfg(feature = "faction")]
pub async fn faction<F>(&self, build: F) -> Result<crate::faction::Response, E::Error> pub async fn faction<F>(&self, build: F) -> Result<crate::faction::Response, E::Error>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::faction::Response>, crate::ApiRequestBuilder<crate::faction::Selection>,
) -> crate::ApiRequestBuilder<crate::faction::Response>, ) -> crate::ApiRequestBuilder<crate::faction::Selection>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
@ -73,6 +79,7 @@ where
self.executor self.executor
.execute(self.client, builder.request, builder.id) .execute(self.client, builder.request, builder.id)
.await .await
.map(crate::faction::Response::from_response)
} }
#[cfg(feature = "faction")] #[cfg(feature = "faction")]
@ -83,8 +90,8 @@ where
) -> HashMap<I, Result<crate::faction::Response, E::Error>> ) -> HashMap<I, Result<crate::faction::Response, E::Error>>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::faction::Response>, crate::ApiRequestBuilder<crate::faction::Selection>,
) -> crate::ApiRequestBuilder<crate::faction::Response>, ) -> crate::ApiRequestBuilder<crate::faction::Selection>,
I: ToString + std::hash::Hash + std::cmp::Eq, I: ToString + std::hash::Hash + std::cmp::Eq,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
@ -94,14 +101,17 @@ where
self.executor self.executor
.execute_many(self.client, builder.request, Vec::from_iter(ids)) .execute_many(self.client, builder.request, Vec::from_iter(ids))
.await .await
.into_iter()
.map(|(k, v)| (k, v.map(crate::faction::Response::from_response)))
.collect()
} }
#[cfg(feature = "torn")] #[cfg(feature = "torn")]
pub async fn torn<F>(&self, build: F) -> Result<crate::torn::Response, E::Error> pub async fn torn<F>(&self, build: F) -> Result<crate::torn::Response, E::Error>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::torn::Response>, crate::ApiRequestBuilder<crate::torn::Selection>,
) -> crate::ApiRequestBuilder<crate::torn::Response>, ) -> crate::ApiRequestBuilder<crate::torn::Selection>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
@ -109,6 +119,7 @@ where
self.executor self.executor
.execute(self.client, builder.request, builder.id) .execute(self.client, builder.request, builder.id)
.await .await
.map(crate::torn::Response::from_response)
} }
#[cfg(feature = "torn")] #[cfg(feature = "torn")]
@ -119,8 +130,8 @@ where
) -> HashMap<I, Result<crate::torn::Response, E::Error>> ) -> HashMap<I, Result<crate::torn::Response, E::Error>>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::torn::Response>, crate::ApiRequestBuilder<crate::torn::Selection>,
) -> crate::ApiRequestBuilder<crate::torn::Response>, ) -> crate::ApiRequestBuilder<crate::torn::Selection>,
I: ToString + std::hash::Hash + std::cmp::Eq, I: ToString + std::hash::Hash + std::cmp::Eq,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
@ -130,14 +141,17 @@ where
self.executor self.executor
.execute_many(self.client, builder.request, Vec::from_iter(ids)) .execute_many(self.client, builder.request, Vec::from_iter(ids))
.await .await
.into_iter()
.map(|(k, v)| (k, v.map(crate::torn::Response::from_response)))
.collect()
} }
#[cfg(feature = "key")] #[cfg(feature = "key")]
pub async fn key<F>(&self, build: F) -> Result<crate::key::Response, E::Error> pub async fn key<F>(&self, build: F) -> Result<crate::key::Response, E::Error>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::key::Response>, crate::ApiRequestBuilder<crate::key::Selection>,
) -> crate::ApiRequestBuilder<crate::key::Response>, ) -> crate::ApiRequestBuilder<crate::key::Selection>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
@ -145,6 +159,7 @@ where
self.executor self.executor
.execute(self.client, builder.request, builder.id) .execute(self.client, builder.request, builder.id)
.await .await
.map(crate::key::Response::from_response)
} }
} }
@ -160,18 +175,18 @@ where
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
id: Option<String>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<ApiResponse, Self::Error>
where where
A: ApiCategoryResponse; A: ApiSelection;
async fn execute_many<A, I>( async fn execute_many<A, I>(
&self, &self,
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
ids: Vec<I>, ids: Vec<I>,
) -> HashMap<I, Result<A, Self::Error>> ) -> HashMap<I, Result<ApiResponse, Self::Error>>
where where
A: ApiCategoryResponse, A: ApiSelection,
I: ToString + std::hash::Hash + std::cmp::Eq; I: ToString + std::hash::Hash + std::cmp::Eq;
} }
@ -187,15 +202,15 @@ where
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
id: Option<String>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<ApiResponse, Self::Error>
where where
A: ApiCategoryResponse, A: ApiSelection,
{ {
let url = request.url(&self.key, id.as_deref()); let url = request.url(&self.key, id.as_deref());
let value = client.request(url).await.map_err(ApiClientError::Client)?; let value = client.request(url).await.map_err(ApiClientError::Client)?;
Ok(A::from_response(ApiResponse::from_value(value)?)) Ok(ApiResponse::from_value(value)?)
} }
async fn execute_many<A, I>( async fn execute_many<A, I>(
@ -203,9 +218,9 @@ where
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
ids: Vec<I>, ids: Vec<I>,
) -> HashMap<I, Result<A, Self::Error>> ) -> HashMap<I, Result<ApiResponse, Self::Error>>
where where
A: ApiCategoryResponse, A: ApiSelection,
I: ToString + std::hash::Hash + std::cmp::Eq, I: ToString + std::hash::Hash + std::cmp::Eq,
{ {
let request_ref = &request; let request_ref = &request;
@ -217,9 +232,7 @@ where
( (
i, i,
value value.and_then(|v| ApiResponse::from_value(v).map_err(Into::into)),
.and_then(|v| ApiResponse::from_value(v).map_err(Into::into))
.map(A::from_response),
) )
})) }))
.await; .await;

67
torn-api/src/send.rs
View file

@ -2,7 +2,9 @@ use std::collections::HashMap;
use async_trait::async_trait; use async_trait::async_trait;
use crate::{ApiCategoryResponse, ApiClientError, ApiRequest, ApiResponse, DirectExecutor}; use crate::{
ApiCategoryResponse, ApiClientError, ApiRequest, ApiResponse, ApiSelection, DirectExecutor,
};
pub struct ApiProvider<'a, C, E> pub struct ApiProvider<'a, C, E>
where where
@ -28,8 +30,8 @@ where
pub async fn user<F>(&self, build: F) -> Result<crate::user::Response, E::Error> pub async fn user<F>(&self, build: F) -> Result<crate::user::Response, E::Error>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::user::Response>, crate::ApiRequestBuilder<crate::user::Selection>,
) -> crate::ApiRequestBuilder<crate::user::Response>, ) -> crate::ApiRequestBuilder<crate::user::Selection>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
@ -37,6 +39,7 @@ where
self.executor self.executor
.execute(self.client, builder.request, builder.id) .execute(self.client, builder.request, builder.id)
.await .await
.map(crate::user::Response::from_response)
} }
#[cfg(feature = "user")] #[cfg(feature = "user")]
@ -47,8 +50,8 @@ where
) -> HashMap<I, Result<crate::user::Response, E::Error>> ) -> HashMap<I, Result<crate::user::Response, E::Error>>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::user::Response>, crate::ApiRequestBuilder<crate::user::Selection>,
) -> crate::ApiRequestBuilder<crate::user::Response>, ) -> crate::ApiRequestBuilder<crate::user::Selection>,
I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync, I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
@ -58,14 +61,17 @@ where
self.executor self.executor
.execute_many(self.client, builder.request, Vec::from_iter(ids)) .execute_many(self.client, builder.request, Vec::from_iter(ids))
.await .await
.into_iter()
.map(|(k, v)| (k, v.map(crate::user::Response::from_response)))
.collect()
} }
#[cfg(feature = "faction")] #[cfg(feature = "faction")]
pub async fn faction<F>(&self, build: F) -> Result<crate::faction::Response, E::Error> pub async fn faction<F>(&self, build: F) -> Result<crate::faction::Response, E::Error>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::faction::Response>, crate::ApiRequestBuilder<crate::faction::Selection>,
) -> crate::ApiRequestBuilder<crate::faction::Response>, ) -> crate::ApiRequestBuilder<crate::faction::Selection>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
@ -73,6 +79,7 @@ where
self.executor self.executor
.execute(self.client, builder.request, builder.id) .execute(self.client, builder.request, builder.id)
.await .await
.map(crate::faction::Response::from_response)
} }
#[cfg(feature = "faction")] #[cfg(feature = "faction")]
@ -83,8 +90,8 @@ where
) -> HashMap<I, Result<crate::faction::Response, E::Error>> ) -> HashMap<I, Result<crate::faction::Response, E::Error>>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::faction::Response>, crate::ApiRequestBuilder<crate::faction::Selection>,
) -> crate::ApiRequestBuilder<crate::faction::Response>, ) -> crate::ApiRequestBuilder<crate::faction::Selection>,
I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync, I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
@ -94,14 +101,17 @@ where
self.executor self.executor
.execute_many(self.client, builder.request, Vec::from_iter(ids)) .execute_many(self.client, builder.request, Vec::from_iter(ids))
.await .await
.into_iter()
.map(|(k, v)| (k, v.map(crate::faction::Response::from_response)))
.collect()
} }
#[cfg(feature = "torn")] #[cfg(feature = "torn")]
pub async fn torn<F>(&self, build: F) -> Result<crate::torn::Response, E::Error> pub async fn torn<F>(&self, build: F) -> Result<crate::torn::Response, E::Error>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::torn::Response>, crate::ApiRequestBuilder<crate::torn::Selection>,
) -> crate::ApiRequestBuilder<crate::torn::Response>, ) -> crate::ApiRequestBuilder<crate::torn::Selection>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
@ -109,6 +119,7 @@ where
self.executor self.executor
.execute(self.client, builder.request, builder.id) .execute(self.client, builder.request, builder.id)
.await .await
.map(crate::torn::Response::from_response)
} }
#[cfg(feature = "torn")] #[cfg(feature = "torn")]
@ -119,8 +130,8 @@ where
) -> HashMap<I, Result<crate::torn::Response, E::Error>> ) -> HashMap<I, Result<crate::torn::Response, E::Error>>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::torn::Response>, crate::ApiRequestBuilder<crate::torn::Selection>,
) -> crate::ApiRequestBuilder<crate::torn::Response>, ) -> crate::ApiRequestBuilder<crate::torn::Selection>,
I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync, I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
@ -130,14 +141,17 @@ where
self.executor self.executor
.execute_many(self.client, builder.request, Vec::from_iter(ids)) .execute_many(self.client, builder.request, Vec::from_iter(ids))
.await .await
.into_iter()
.map(|(k, v)| (k, v.map(crate::torn::Response::from_response)))
.collect()
} }
#[cfg(feature = "key")] #[cfg(feature = "key")]
pub async fn key<F>(&self, build: F) -> Result<crate::key::Response, E::Error> pub async fn key<F>(&self, build: F) -> Result<crate::key::Response, E::Error>
where where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::key::Response>, crate::ApiRequestBuilder<crate::key::Selection>,
) -> crate::ApiRequestBuilder<crate::key::Response>, ) -> crate::ApiRequestBuilder<crate::key::Selection>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
@ -145,6 +159,7 @@ where
self.executor self.executor
.execute(self.client, builder.request, builder.id) .execute(self.client, builder.request, builder.id)
.await .await
.map(crate::key::Response::from_response)
} }
} }
@ -160,18 +175,18 @@ where
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
id: Option<String>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<ApiResponse, Self::Error>
where where
A: ApiCategoryResponse; A: ApiSelection;
async fn execute_many<A, I>( async fn execute_many<A, I>(
&self, &self,
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
ids: Vec<I>, ids: Vec<I>,
) -> HashMap<I, Result<A, Self::Error>> ) -> HashMap<I, Result<ApiResponse, Self::Error>>
where where
A: ApiCategoryResponse, A: ApiSelection,
I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync; I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync;
} }
@ -187,15 +202,15 @@ where
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
id: Option<String>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<ApiResponse, Self::Error>
where where
A: ApiCategoryResponse, A: ApiSelection,
{ {
let url = request.url(&self.key, id.as_deref()); let url = request.url(&self.key, id.as_deref());
let value = client.request(url).await.map_err(ApiClientError::Client)?; let value = client.request(url).await.map_err(ApiClientError::Client)?;
Ok(A::from_response(ApiResponse::from_value(value)?)) Ok(ApiResponse::from_value(value)?)
} }
async fn execute_many<A, I>( async fn execute_many<A, I>(
@ -203,9 +218,9 @@ where
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
ids: Vec<I>, ids: Vec<I>,
) -> HashMap<I, Result<A, Self::Error>> ) -> HashMap<I, Result<ApiResponse, Self::Error>>
where where
A: ApiCategoryResponse, A: ApiSelection,
I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync, I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync,
{ {
let request_ref = &request; let request_ref = &request;
@ -217,9 +232,7 @@ where
( (
i, i,
value value.and_then(|v| ApiResponse::from_value(v).map_err(Into::into)),
.and_then(|v| ApiResponse::from_value(v).map_err(Into::into))
.map(A::from_response),
) )
})) }))
.await; .await;

4
torn-key-pool/Cargo.toml
View file

@ -1,6 +1,6 @@
[package] [package]
name = "torn-key-pool" name = "torn-key-pool"
version = "0.5.5" version = "0.5.6"
edition = "2021" edition = "2021"
authors = ["Pyrit [2111649]"] authors = ["Pyrit [2111649]"]
license = "MIT" license = "MIT"
@ -17,7 +17,7 @@ tokio-runtime = [ "dep:tokio", "dep:rand" ]
actix-runtime = [ "dep:actix-rt", "dep:rand" ] actix-runtime = [ "dep:actix-rt", "dep:rand" ]
[dependencies] [dependencies]
torn-api = { path = "../torn-api", default-features = false, version = "0.5.5" } torn-api = { path = "../torn-api", default-features = false, version = "0.5.10" }
async-trait = "0.1" async-trait = "0.1"
thiserror = "1" thiserror = "1"

14
torn-key-pool/src/local.rs
View file

@ -4,7 +4,7 @@ use async_trait::async_trait;
use torn_api::{ use torn_api::{
local::{ApiClient, ApiProvider, RequestExecutor}, local::{ApiClient, ApiProvider, RequestExecutor},
ApiCategoryResponse, ApiRequest, ApiResponse, ResponseError, ApiRequest, ApiResponse, ApiSelection, ResponseError,
}; };
use crate::{ApiKey, KeyPoolError, KeyPoolExecutor, KeyPoolStorage}; use crate::{ApiKey, KeyPoolError, KeyPoolExecutor, KeyPoolStorage};
@ -22,9 +22,9 @@ where
client: &C, client: &C,
mut request: ApiRequest<A>, mut request: ApiRequest<A>,
id: Option<String>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<ApiResponse, Self::Error>
where where
A: ApiCategoryResponse, A: ApiSelection,
{ {
request.comment = self.comment.map(ToOwned::to_owned); request.comment = self.comment.map(ToOwned::to_owned);
loop { loop {
@ -49,7 +49,7 @@ where
} }
} }
Err(parsing_error) => return Err(KeyPoolError::Response(parsing_error)), Err(parsing_error) => return Err(KeyPoolError::Response(parsing_error)),
Ok(res) => return Ok(A::from_response(res)), Ok(res) => return Ok(res),
}; };
} }
} }
@ -59,9 +59,9 @@ where
client: &C, client: &C,
mut request: ApiRequest<A>, mut request: ApiRequest<A>,
ids: Vec<I>, ids: Vec<I>,
) -> HashMap<I, Result<A, Self::Error>> ) -> HashMap<I, Result<ApiResponse, Self::Error>>
where where
A: ApiCategoryResponse, A: ApiSelection,
I: ToString + std::hash::Hash + std::cmp::Eq, I: ToString + std::hash::Hash + std::cmp::Eq,
{ {
let keys = match self let keys = match self
@ -111,7 +111,7 @@ where
Err(parsing_error) => { Err(parsing_error) => {
return (id, Err(KeyPoolError::Response(parsing_error))) return (id, Err(KeyPoolError::Response(parsing_error)))
} }
Ok(res) => return (id, Ok(A::from_response(res))), Ok(res) => return (id, Ok(res)),
}; };
key = match self.storage.acquire_key(self.domain.clone()).await { key = match self.storage.acquire_key(self.domain.clone()).await {

14
torn-key-pool/src/send.rs
View file

@ -4,7 +4,7 @@ use async_trait::async_trait;
use torn_api::{ use torn_api::{
send::{ApiClient, ApiProvider, RequestExecutor}, send::{ApiClient, ApiProvider, RequestExecutor},
ApiCategoryResponse, ApiRequest, ApiResponse, ResponseError, ApiRequest, ApiResponse, ApiSelection, ResponseError,
}; };
use crate::{ApiKey, KeyPoolError, KeyPoolExecutor, KeyPoolStorage}; use crate::{ApiKey, KeyPoolError, KeyPoolExecutor, KeyPoolStorage};
@ -22,9 +22,9 @@ where
client: &C, client: &C,
mut request: ApiRequest<A>, mut request: ApiRequest<A>,
id: Option<String>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<ApiResponse, Self::Error>
where where
A: ApiCategoryResponse, A: ApiSelection,
{ {
request.comment = self.comment.map(ToOwned::to_owned); request.comment = self.comment.map(ToOwned::to_owned);
loop { loop {
@ -49,7 +49,7 @@ where
} }
} }
Err(parsing_error) => return Err(KeyPoolError::Response(parsing_error)), Err(parsing_error) => return Err(KeyPoolError::Response(parsing_error)),
Ok(res) => return Ok(A::from_response(res)), Ok(res) => return Ok(res),
}; };
} }
} }
@ -59,9 +59,9 @@ where
client: &C, client: &C,
mut request: ApiRequest<A>, mut request: ApiRequest<A>,
ids: Vec<I>, ids: Vec<I>,
) -> HashMap<I, Result<A, Self::Error>> ) -> HashMap<I, Result<ApiResponse, Self::Error>>
where where
A: ApiCategoryResponse, A: ApiSelection,
I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync, I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync,
{ {
let keys = match self let keys = match self
@ -111,7 +111,7 @@ where
Err(parsing_error) => { Err(parsing_error) => {
return (id, Err(KeyPoolError::Response(parsing_error))) return (id, Err(KeyPoolError::Response(parsing_error)))
} }
Ok(res) => return (id, Ok(A::from_response(res))), Ok(res) => return (id, Ok(res)),
}; };
key = match self.storage.acquire_key(self.domain.clone()).await { key = match self.storage.acquire_key(self.domain.clone()).await {