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

added territory selections

Browse source
This commit is contained in:
TotallyNot 2023-02-21 01:34:46 +01:00
parent 7e97b736ad
commit 3757d1778f
10 changed files with 177 additions and 177 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
torn-api/Cargo.toml
View file

@ -1,6 +1,6 @@
[package] [package]
name = "torn-api" name = "torn-api"
version = "0.5.7" version = "0.5.8"
edition = "2021" edition = "2021"
authors = ["Pyrit [2111649]"] authors = ["Pyrit [2111649]"]
license = "MIT" license = "MIT"
@ -31,7 +31,6 @@ serde_json = "1"
chrono = { version = "0.4", features = [ "serde" ], default-features = false } chrono = { version = "0.4", features = [ "serde" ], default-features = false }
async-trait = "0.1" async-trait = "0.1"
thiserror = "1" thiserror = "1"
num-traits = "0.2"
futures = "0.3" futures = "0.3"
reqwest = { version = "0.11", default-features = false, features = [ "json" ], optional = true } reqwest = { version = "0.11", default-features = false, features = [ "json" ], optional = true }

9
torn-api/src/common.rs
View file

@ -39,3 +39,12 @@ pub struct Status<'a> {
#[serde(deserialize_with = "de_util::zero_date_is_none")] #[serde(deserialize_with = "de_util::zero_date_is_none")]
pub until: Option<DateTime<Utc>>, pub until: Option<DateTime<Utc>>,
} }
#[derive(Debug, Clone, Deserialize)]
pub struct Territory {
pub sector: i16,
pub size: i16,
pub density: i16,
pub daily_respect: i16,
pub faction: i32,
}

12
torn-api/src/faction.rs
View file

@ -1,4 +1,4 @@
use std::collections::BTreeMap; use std::collections::{BTreeMap, HashMap};
use chrono::{serde::ts_seconds, DateTime, Utc}; use chrono::{serde::ts_seconds, DateTime, Utc};
use serde::Deserialize; use serde::Deserialize;
@ -7,7 +7,7 @@ use torn_api_macros::ApiCategory;
use crate::de_util; use crate::de_util;
pub use crate::common::{LastAction, Status}; pub use crate::common::{LastAction, Status, Territory};
#[derive(Debug, Clone, Copy, ApiCategory)] #[derive(Debug, Clone, Copy, ApiCategory)]
#[api(category = "faction")] #[api(category = "faction")]
@ -20,6 +20,9 @@ pub enum Selection {
#[api(type = "BTreeMap<i32, AttackFull>", field = "attacks")] #[api(type = "BTreeMap<i32, AttackFull>", field = "attacks")]
Attacks, Attacks,
#[api(type = "HashMap<String, Territory>", field = "territory")]
Territory,
} }
#[derive(Debug, Clone, Deserialize)] #[derive(Debug, Clone, Deserialize)]
@ -164,12 +167,15 @@ mod tests {
let response = Client::default() let response = Client::default()
.torn_api(key) .torn_api(key)
.faction(|b| b.selections(&[Selection::Basic, Selection::Attacks])) .faction(|b| {
b.selections(&[Selection::Basic, Selection::Attacks, Selection::Territory])
})
.await .await
.unwrap(); .unwrap();
response.basic().unwrap(); response.basic().unwrap();
response.attacks().unwrap(); response.attacks().unwrap();
response.attacks_full().unwrap(); response.attacks_full().unwrap();
response.territory().unwrap();
} }
} }

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

@ -165,7 +165,7 @@ impl<A> ApiRequest<A>
where where
A: ApiCategoryResponse, A: ApiCategoryResponse,
{ {
pub fn url(&self, key: &str, id: Option<i64>) -> 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::Selection::category());
if let Some(id) = id { if let Some(id) = id {
@ -195,7 +195,7 @@ where
A: ApiCategoryResponse, A: ApiCategoryResponse,
{ {
request: ApiRequest<A>, request: ApiRequest<A>,
id: Option<i64>, id: Option<String>,
} }
impl<A> Default for ApiRequestBuilder<A> impl<A> Default for ApiRequestBuilder<A>
@ -243,9 +243,9 @@ where
#[must_use] #[must_use]
pub fn id<I>(mut self, id: I) -> Self pub fn id<I>(mut self, id: I) -> Self
where where
I: num_traits::AsPrimitive<i64>, I: ToString,
{ {
self.id = Some(id.as_()); self.id = Some(id.to_string());
self self
} }
} }

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

@ -49,23 +49,15 @@ where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::user::Response>, crate::ApiRequestBuilder<crate::user::Response>,
) -> crate::ApiRequestBuilder<crate::user::Response>, ) -> crate::ApiRequestBuilder<crate::user::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq, I: ToString + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
self.executor self.executor
.execute_many( .execute_many(self.client, builder.request, Vec::from_iter(ids))
self.client,
builder.request,
ids.into_iter().map(|i| i.as_()).collect(),
)
.await .await
.into_iter()
.map(|(i, r)| (num_traits::AsPrimitive::as_(i), r))
.collect()
} }
#[cfg(feature = "faction")] #[cfg(feature = "faction")]
@ -93,23 +85,15 @@ where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::faction::Response>, crate::ApiRequestBuilder<crate::faction::Response>,
) -> crate::ApiRequestBuilder<crate::faction::Response>, ) -> crate::ApiRequestBuilder<crate::faction::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq, I: ToString + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
self.executor self.executor
.execute_many( .execute_many(self.client, builder.request, Vec::from_iter(ids))
self.client,
builder.request,
ids.into_iter().map(|i| i.as_()).collect(),
)
.await .await
.into_iter()
.map(|(i, r)| (num_traits::AsPrimitive::as_(i), r))
.collect()
} }
#[cfg(feature = "torn")] #[cfg(feature = "torn")]
@ -137,23 +121,15 @@ where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::torn::Response>, crate::ApiRequestBuilder<crate::torn::Response>,
) -> crate::ApiRequestBuilder<crate::torn::Response>, ) -> crate::ApiRequestBuilder<crate::torn::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq, I: ToString + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
self.executor self.executor
.execute_many( .execute_many(self.client, builder.request, Vec::from_iter(ids))
self.client,
builder.request,
ids.into_iter().map(|i| i.as_()).collect(),
)
.await .await
.into_iter()
.map(|(i, r)| (num_traits::AsPrimitive::as_(i), r))
.collect()
} }
#[cfg(feature = "key")] #[cfg(feature = "key")]
@ -183,19 +159,20 @@ where
&self, &self,
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
id: Option<i64>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<A, Self::Error>
where where
A: ApiCategoryResponse; A: ApiCategoryResponse;
async fn execute_many<A>( async fn execute_many<A, I>(
&self, &self,
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
ids: Vec<i64>, ids: Vec<I>,
) -> HashMap<i64, Result<A, Self::Error>> ) -> HashMap<I, Result<A, Self::Error>>
where where
A: ApiCategoryResponse; A: ApiCategoryResponse,
I: ToString + std::hash::Hash + std::cmp::Eq;
} }
#[async_trait(?Send)] #[async_trait(?Send)]
@ -209,30 +186,32 @@ where
&self, &self,
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
id: Option<i64>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<A, Self::Error>
where where
A: ApiCategoryResponse, A: ApiCategoryResponse,
{ {
let url = request.url(&self.key, id); 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(A::from_response(ApiResponse::from_value(value)?))
} }
async fn execute_many<A>( async fn execute_many<A, I>(
&self, &self,
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
ids: Vec<i64>, ids: Vec<I>,
) -> HashMap<i64, Result<A, Self::Error>> ) -> HashMap<I, Result<A, Self::Error>>
where where
A: ApiCategoryResponse, A: ApiCategoryResponse,
I: ToString + std::hash::Hash + std::cmp::Eq,
{ {
let request_ref = &request; let request_ref = &request;
futures::future::join_all(ids.into_iter().map(|i| async move { let tuples = futures::future::join_all(ids.into_iter().map(|i| async move {
let url = request_ref.url(&self.key, Some(i)); let id_string = i.to_string();
let url = request_ref.url(&self.key, Some(&id_string));
let value = client.request(url).await.map_err(ApiClientError::Client); let value = client.request(url).await.map_err(ApiClientError::Client);
@ -243,9 +222,9 @@ where
.map(A::from_response), .map(A::from_response),
) )
})) }))
.await .await;
.into_iter()
.collect() HashMap::from_iter(tuples)
} }
} }

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

@ -49,23 +49,15 @@ where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::user::Response>, crate::ApiRequestBuilder<crate::user::Response>,
) -> crate::ApiRequestBuilder<crate::user::Response>, ) -> crate::ApiRequestBuilder<crate::user::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq, I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
self.executor self.executor
.execute_many( .execute_many(self.client, builder.request, Vec::from_iter(ids))
self.client,
builder.request,
ids.into_iter().map(|i| i.as_()).collect(),
)
.await .await
.into_iter()
.map(|(i, r)| (num_traits::AsPrimitive::as_(i), r))
.collect()
} }
#[cfg(feature = "faction")] #[cfg(feature = "faction")]
@ -93,23 +85,15 @@ where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::faction::Response>, crate::ApiRequestBuilder<crate::faction::Response>,
) -> crate::ApiRequestBuilder<crate::faction::Response>, ) -> crate::ApiRequestBuilder<crate::faction::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq, I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
self.executor self.executor
.execute_many( .execute_many(self.client, builder.request, Vec::from_iter(ids))
self.client,
builder.request,
ids.into_iter().map(|i| i.as_()).collect(),
)
.await .await
.into_iter()
.map(|(i, r)| (num_traits::AsPrimitive::as_(i), r))
.collect()
} }
#[cfg(feature = "torn")] #[cfg(feature = "torn")]
@ -137,23 +121,15 @@ where
F: FnOnce( F: FnOnce(
crate::ApiRequestBuilder<crate::torn::Response>, crate::ApiRequestBuilder<crate::torn::Response>,
) -> crate::ApiRequestBuilder<crate::torn::Response>, ) -> crate::ApiRequestBuilder<crate::torn::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq, I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>, L: IntoIterator<Item = I>,
{ {
let mut builder = crate::ApiRequestBuilder::default(); let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder); builder = build(builder);
self.executor self.executor
.execute_many( .execute_many(self.client, builder.request, Vec::from_iter(ids))
self.client,
builder.request,
ids.into_iter().map(|i| i.as_()).collect(),
)
.await .await
.into_iter()
.map(|(i, r)| (num_traits::AsPrimitive::as_(i), r))
.collect()
} }
#[cfg(feature = "key")] #[cfg(feature = "key")]
@ -183,19 +159,20 @@ where
&self, &self,
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
id: Option<i64>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<A, Self::Error>
where where
A: ApiCategoryResponse; A: ApiCategoryResponse;
async fn execute_many<A>( async fn execute_many<A, I>(
&self, &self,
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
ids: Vec<i64>, ids: Vec<I>,
) -> HashMap<i64, Result<A, Self::Error>> ) -> HashMap<I, Result<A, Self::Error>>
where where
A: ApiCategoryResponse; A: ApiCategoryResponse,
I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync;
} }
#[async_trait] #[async_trait]
@ -209,30 +186,32 @@ where
&self, &self,
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
id: Option<i64>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<A, Self::Error>
where where
A: ApiCategoryResponse, A: ApiCategoryResponse,
{ {
let url = request.url(&self.key, id); 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(A::from_response(ApiResponse::from_value(value)?))
} }
async fn execute_many<A>( async fn execute_many<A, I>(
&self, &self,
client: &C, client: &C,
request: ApiRequest<A>, request: ApiRequest<A>,
ids: Vec<i64>, ids: Vec<I>,
) -> HashMap<i64, Result<A, Self::Error>> ) -> HashMap<I, Result<A, Self::Error>>
where where
A: ApiCategoryResponse, A: ApiCategoryResponse,
I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync,
{ {
let request_ref = &request; let request_ref = &request;
futures::future::join_all(ids.into_iter().map(|i| async move { let tuples = futures::future::join_all(ids.into_iter().map(|i| async move {
let url = request_ref.url(&self.key, Some(i)); let id_string = i.to_string();
let url = request_ref.url(&self.key, Some(&id_string));
let value = client.request(url).await.map_err(ApiClientError::Client); let value = client.request(url).await.map_err(ApiClientError::Client);
@ -243,9 +222,9 @@ where
.map(A::from_response), .map(A::from_response),
) )
})) }))
.await .await;
.into_iter()
.collect() HashMap::from_iter(tuples)
} }
} }

20
torn-api/src/torn.rs
View file

@ -1,3 +1,6 @@
use std::collections::HashMap;
use chrono::{DateTime, Utc};
use serde::{ use serde::{
de::{self, MapAccess, Visitor}, de::{self, MapAccess, Visitor},
Deserialize, Deserialize,
@ -16,6 +19,9 @@ pub enum Selection {
type = "Option<Competition>" type = "Option<Competition>"
)] )]
Competition, Competition,
#[api(type = "HashMap<String, TerritoryWar>", field = "territorywars")]
TerritoryWars,
} }
#[derive(Deserialize)] #[derive(Deserialize)]
@ -94,6 +100,17 @@ where
deserializer.deserialize_option(CompetitionVisitor) deserializer.deserialize_option(CompetitionVisitor)
} }
#[derive(Debug, Clone, Deserialize)]
pub struct TerritoryWar {
pub assaulting_faction: i32,
pub defending_faction: i32,
#[serde(with = "chrono::serde::ts_seconds")]
pub started: DateTime<Utc>,
#[serde(with = "chrono::serde::ts_seconds")]
pub ends: DateTime<Utc>,
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
@ -105,10 +122,11 @@ mod tests {
let response = Client::default() let response = Client::default()
.torn_api(key) .torn_api(key)
.torn(|b| b.selections(&[Selection::Competition])) .torn(|b| b.selections(&[Selection::Competition, Selection::TerritoryWars]))
.await .await
.unwrap(); .unwrap();
response.competition().unwrap(); response.competition().unwrap();
response.territory_wars().unwrap();
} }
} }

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

@ -1,6 +1,6 @@
[package] [package]
name = "torn-key-pool" name = "torn-key-pool"
version = "0.5.3" version = "0.5.4"
edition = "2021" edition = "2021"
authors = ["Pyrit [2111649]"] authors = ["Pyrit [2111649]"]
license = "MIT" license = "MIT"

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

@ -21,7 +21,7 @@ where
&self, &self,
client: &C, client: &C,
mut request: ApiRequest<A>, mut request: ApiRequest<A>,
id: Option<i64>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<A, Self::Error>
where where
A: ApiCategoryResponse, A: ApiCategoryResponse,
@ -33,7 +33,7 @@ where
.acquire_key(self.domain.clone()) .acquire_key(self.domain.clone())
.await .await
.map_err(|e| KeyPoolError::Storage(Arc::new(e)))?; .map_err(|e| KeyPoolError::Storage(Arc::new(e)))?;
let url = request.url(key.value(), id); let url = request.url(key.value(), id.as_deref());
let value = client.request(url).await?; let value = client.request(url).await?;
match ApiResponse::from_value(value) { match ApiResponse::from_value(value) {
@ -54,14 +54,15 @@ where
} }
} }
async fn execute_many<A>( async fn execute_many<A, I>(
&self, &self,
client: &C, client: &C,
mut request: ApiRequest<A>, mut request: ApiRequest<A>,
ids: Vec<i64>, ids: Vec<I>,
) -> HashMap<i64, Result<A, Self::Error>> ) -> HashMap<I, Result<A, Self::Error>>
where where
A: ApiCategoryResponse, A: ApiCategoryResponse,
I: ToString + std::hash::Hash + std::cmp::Eq,
{ {
let keys = match self let keys = match self
.storage .storage
@ -81,43 +82,47 @@ where
request.comment = self.comment.map(ToOwned::to_owned); request.comment = self.comment.map(ToOwned::to_owned);
let request_ref = &request; let request_ref = &request;
futures::future::join_all(std::iter::zip(ids, keys).map(|(id, mut key)| async move { let tuples =
loop { futures::future::join_all(std::iter::zip(ids, keys).map(|(id, mut key)| async move {
let url = request_ref.url(key.value(), Some(id)); let id_string = id.to_string();
let value = match client.request(url).await { loop {
Ok(v) => v, let url = request_ref.url(key.value(), Some(&id_string));
Err(why) => return (id, Err(Self::Error::Client(why))), let value = match client.request(url).await {
}; Ok(v) => v,
Err(why) => return (id, Err(Self::Error::Client(why))),
};
match ApiResponse::from_value(value) { match ApiResponse::from_value(value) {
Err(ResponseError::Api { code, reason }) => { Err(ResponseError::Api { code, reason }) => {
match self.storage.flag_key(key, code).await { match self.storage.flag_key(key, code).await {
Ok(false) => { Ok(false) => {
return ( return (
id, id,
Err(KeyPoolError::Response(ResponseError::Api { Err(KeyPoolError::Response(ResponseError::Api {
code, code,
reason, reason,
})), })),
) )
}
Ok(true) => (),
Err(why) => return (id, Err(KeyPoolError::Storage(Arc::new(why)))),
} }
Ok(true) => (),
Err(why) => return (id, Err(KeyPoolError::Storage(Arc::new(why)))),
} }
} 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(A::from_response(res))),
};
key = match self.storage.acquire_key(self.domain.clone()).await { key = match self.storage.acquire_key(self.domain.clone()).await {
Ok(k) => k, Ok(k) => k,
Err(why) => return (id, Err(Self::Error::Storage(Arc::new(why)))), Err(why) => return (id, Err(Self::Error::Storage(Arc::new(why)))),
}; };
} }
})) }))
.await .await;
.into_iter()
.collect() HashMap::from_iter(tuples)
} }
} }

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

@ -21,7 +21,7 @@ where
&self, &self,
client: &C, client: &C,
mut request: ApiRequest<A>, mut request: ApiRequest<A>,
id: Option<i64>, id: Option<String>,
) -> Result<A, Self::Error> ) -> Result<A, Self::Error>
where where
A: ApiCategoryResponse, A: ApiCategoryResponse,
@ -33,7 +33,7 @@ where
.acquire_key(self.domain.clone()) .acquire_key(self.domain.clone())
.await .await
.map_err(|e| KeyPoolError::Storage(Arc::new(e)))?; .map_err(|e| KeyPoolError::Storage(Arc::new(e)))?;
let url = request.url(key.value(), id); let url = request.url(key.value(), id.as_deref());
let value = client.request(url).await?; let value = client.request(url).await?;
match ApiResponse::from_value(value) { match ApiResponse::from_value(value) {
@ -54,14 +54,15 @@ where
} }
} }
async fn execute_many<A>( async fn execute_many<A, I>(
&self, &self,
client: &C, client: &C,
mut request: ApiRequest<A>, mut request: ApiRequest<A>,
ids: Vec<i64>, ids: Vec<I>,
) -> HashMap<i64, Result<A, Self::Error>> ) -> HashMap<I, Result<A, Self::Error>>
where where
A: ApiCategoryResponse, A: ApiCategoryResponse,
I: ToString + std::hash::Hash + std::cmp::Eq + Send + Sync,
{ {
let keys = match self let keys = match self
.storage .storage
@ -81,43 +82,47 @@ where
request.comment = self.comment.map(ToOwned::to_owned); request.comment = self.comment.map(ToOwned::to_owned);
let request_ref = &request; let request_ref = &request;
futures::future::join_all(std::iter::zip(ids, keys).map(|(id, mut key)| async move { let tuples =
loop { futures::future::join_all(std::iter::zip(ids, keys).map(|(id, mut key)| async move {
let url = request_ref.url(key.value(), Some(id)); let id_string = id.to_string();
let value = match client.request(url).await { loop {
Ok(v) => v, let url = request_ref.url(key.value(), Some(&id_string));
Err(why) => return (id, Err(Self::Error::Client(why))), let value = match client.request(url).await {
}; Ok(v) => v,
Err(why) => return (id, Err(Self::Error::Client(why))),
};
match ApiResponse::from_value(value) { match ApiResponse::from_value(value) {
Err(ResponseError::Api { code, reason }) => { Err(ResponseError::Api { code, reason }) => {
match self.storage.flag_key(key, code).await { match self.storage.flag_key(key, code).await {
Ok(false) => { Ok(false) => {
return ( return (
id, id,
Err(KeyPoolError::Response(ResponseError::Api { Err(KeyPoolError::Response(ResponseError::Api {
code, code,
reason, reason,
})), })),
) )
}
Ok(true) => (),
Err(why) => return (id, Err(KeyPoolError::Storage(Arc::new(why)))),
} }
Ok(true) => (),
Err(why) => return (id, Err(KeyPoolError::Storage(Arc::new(why)))),
} }
} 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(A::from_response(res))),
};
key = match self.storage.acquire_key(self.domain.clone()).await { key = match self.storage.acquire_key(self.domain.clone()).await {
Ok(k) => k, Ok(k) => k,
Err(why) => return (id, Err(Self::Error::Storage(Arc::new(why)))), Err(why) => return (id, Err(Self::Error::Storage(Arc::new(why)))),
}; };
} }
})) }))
.await .await;
.into_iter()
.collect() HashMap::from_iter(tuples)
} }
} }