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

fix Competition deserialisation

Browse source
This commit is contained in:
TotallyNot 2023-01-22 00:50:16 +01:00
parent 3b1da4d708
commit 6e1135e102
10 changed files with 405 additions and 155 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
torn-api/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "torn-api"
version = "0.5.3"
version = "0.5.4"
edition = "2021"
authors = ["Pyrit [2111649]"]
license = "MIT"
@ -13,9 +13,16 @@ name = "deserialisation_benchmark"
harness = false
[features]
default = [ "reqwest" ]
default = [ "reqwest", "user", "faction", "torn" ]
reqwest = [ "dep:reqwest" ]
awc = [ "dep:awc" ]
decimal = [ "dep:rust_decimal" ]
user = [ "__common" ]
faction = [ "__common" ]
torn = [ "__common" ]
__common = []
[dependencies]
serde = { version = "1", features = [ "derive" ] }
@ -28,6 +35,7 @@ futures = "0.3"
reqwest = { version = "0.11", default-features = false, features = [ "json" ], optional = true }
awc = { version = "3", default-features = false, optional = true }
rust_decimal = { version = "1", default-features = false, optional = true, features = [ "serde" ] }
torn-api-macros = { path = "../torn-api-macros", version = "0.1.1" }

31
torn-api/benches/deserialisation_benchmark.rs
View file

@ -1,5 +1,5 @@
use criterion::{criterion_group, criterion_main, Criterion};
use torn_api::{faction, user, ThreadSafeApiClient};
use torn_api::{faction, send::ApiClient, user};
pub fn user_benchmark(c: &mut Criterion) {
dotenv::dotenv().unwrap();
@ -54,12 +54,37 @@ pub fn faction_benchmark(c: &mut Criterion) {
.unwrap()
});
c.bench_function("user deserialize", |b| {
c.bench_function("faction deserialize", |b| {
b.iter(|| {
response.basic().unwrap();
})
});
}
criterion_group!(benches, user_benchmark, faction_benchmark);
pub fn attacks_full(c: &mut Criterion) {
dotenv::dotenv().unwrap();
let rt = tokio::runtime::Builder::new_current_thread()
.enable_io()
.enable_time()
.build()
.unwrap();
let response = rt.block_on(async {
let key = std::env::var("APIKEY").expect("api key");
let client = reqwest::Client::default();
client
.torn_api(key)
.faction(|b| b.selections(&[faction::Selection::AttacksFull]))
.await
.unwrap()
});
c.bench_function("attacksfull deserialize", |b| {
b.iter(|| {
response.attacks_full().unwrap();
})
});
}
criterion_group!(benches, user_benchmark, faction_benchmark, attacks_full);
criterion_main!(benches);

41
torn-api/src/common.rs Normal file
View file

@ -0,0 +1,41 @@
use chrono::{serde::ts_seconds, DateTime, Utc};
use serde::Deserialize;
use crate::de_util;
#[derive(Debug, Clone, Deserialize)]
pub struct LastAction {
#[serde(with = "ts_seconds")]
pub timestamp: DateTime<Utc>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
pub enum State {
Okay,
Traveling,
Hospital,
Abroad,
Jail,
Federal,
Fallen,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum StateColour {
Green,
Red,
Blue,
}
#[derive(Debug, Clone, Deserialize)]
pub struct Status<'a> {
pub description: &'a str,
#[serde(deserialize_with = "de_util::empty_string_is_none")]
pub details: Option<&'a str>,
#[serde(rename = "color")]
pub colour: StateColour,
pub state: State,
#[serde(deserialize_with = "de_util::zero_date_is_none")]
pub until: Option<DateTime<Utc>>,
}

52
torn-api/src/de_util.rs
View file

@ -1,11 +1,13 @@
use chrono::{DateTime, NaiveDateTime, Utc};
use serde::de::{Deserialize, Deserializer, Error, Unexpected};
#![allow(unused)]
pub fn empty_string_is_none<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
use chrono::{DateTime, NaiveDateTime, Utc};
use serde::de::{Deserialize, Deserializer, Error, Unexpected, Visitor};
pub(crate) fn empty_string_is_none<'de, D>(deserializer: D) -> Result<Option<&'de str>, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let s: &str = Deserialize::deserialize(deserializer)?;
if s.is_empty() {
Ok(None)
} else {
@ -13,7 +15,7 @@ where
}
}
pub fn string_is_long<'de, D>(deserializer: D) -> Result<Option<i64>, D::Error>
pub(crate) fn string_is_long<'de, D>(deserializer: D) -> Result<Option<i64>, D::Error>
where
D: Deserializer<'de>,
{
@ -27,7 +29,7 @@ where
}
}
pub fn zero_date_is_none<'de, D>(deserializer: D) -> Result<Option<DateTime<Utc>>, D::Error>
pub(crate) fn zero_date_is_none<'de, D>(deserializer: D) -> Result<Option<DateTime<Utc>>, D::Error>
where
D: Deserializer<'de>,
{
@ -40,7 +42,7 @@ where
}
}
pub fn int_is_bool<'de, D>(deserializer: D) -> Result<bool, D::Error>
pub(crate) fn int_is_bool<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
D: Deserializer<'de>,
{
@ -52,3 +54,39 @@ where
x => Err(Error::invalid_value(Unexpected::Signed(x), &"0 or 1")),
}
}
pub(crate) fn empty_string_int_option<'de, D>(deserializer: D) -> Result<Option<i32>, D::Error>
where
D: Deserializer<'de>,
{
struct DumbVisitor;
impl<'de> Visitor<'de> for DumbVisitor {
type Value = Option<i32>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(formatter, "Empty string or integer")
}
// serde_json will treat all unsigned integers as u64
fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
where
E: Error,
{
Ok(Some(v as i32))
}
fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
where
E: Error,
{
if v.is_empty() {
Ok(None)
} else {
Err(E::invalid_value(Unexpected::Str(v), &self))
}
}
}
deserializer.deserialize_any(DumbVisitor)
}

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

@ -1,31 +1,42 @@
use std::collections::BTreeMap;
use chrono::{serde::ts_seconds, DateTime, Utc};
use serde::Deserialize;
use torn_api_macros::ApiCategory;
use crate::de_util;
pub use crate::common::{LastAction, Status};
#[derive(Debug, Clone, Copy, ApiCategory)]
#[api(category = "faction")]
pub enum Selection {
#[api(type = "Basic", flatten)]
Basic,
#[api(type = "BTreeMap<i32, Attack>", field = "attacks")]
AttacksFull,
#[api(type = "BTreeMap<i32, AttackFull>", field = "attacks")]
Attacks,
}
#[derive(Debug, Clone, Deserialize)]
pub struct Member {
pub name: String,
pub struct Member<'a> {
pub name: &'a str,
pub level: i16,
pub days_in_faction: i16,
pub position: String,
pub status: super::user::Status,
pub last_action: super::user::LastAction,
pub position: &'a str,
pub status: Status<'a>,
pub last_action: LastAction,
}
#[derive(Debug, Clone, Deserialize)]
pub struct Basic {
pub struct Basic<'a> {
#[serde(rename = "ID")]
pub id: i32,
pub name: String,
pub name: &'a str,
pub leader: i32,
pub respect: i32,
@ -33,7 +44,112 @@ pub struct Basic {
pub capacity: i16,
pub best_chain: i32,
pub members: BTreeMap<i32, Member>,
#[serde(borrow)]
pub members: BTreeMap<i32, Member<'a>>,
}
#[derive(Debug, Clone, Copy, Deserialize)]
pub enum AttackResult {
Attacked,
Mugged,
Hospitalized,
Lost,
Arrested,
Escape,
Interrupted,
Assist,
Timeout,
Stalemate,
Special,
}
#[derive(Debug, Clone, Deserialize)]
pub struct Attack<'a> {
pub code: &'a str,
#[serde(with = "ts_seconds")]
pub timestamp_started: DateTime<Utc>,
#[serde(with = "ts_seconds")]
pub timestamp_ended: DateTime<Utc>,
#[serde(deserialize_with = "de_util::empty_string_int_option")]
pub attacker_id: Option<i32>,
#[serde(deserialize_with = "de_util::empty_string_int_option")]
pub attacker_faction: Option<i32>,
pub defender_id: i32,
#[serde(deserialize_with = "de_util::empty_string_int_option")]
pub defender_faction: Option<i32>,
pub result: AttackResult,
#[serde(deserialize_with = "de_util::int_is_bool")]
pub stealthed: bool,
#[cfg(feature = "decimal")]
pub respect: rust_decimal::Decimal,
#[cfg(not(feature = "decimal"))]
pub respect: f32,
}
#[derive(Debug, Clone, Deserialize)]
pub struct RespectModifiers {
pub fair_fight: f32,
pub war: f32,
pub retaliation: f32,
pub group_attack: f32,
pub overseas: f32,
pub chain_bonus: f32,
}
#[derive(Debug, Clone, Deserialize)]
pub struct AttackFull<'a> {
pub code: &'a str,
#[serde(with = "ts_seconds")]
pub timestamp_started: DateTime<Utc>,
#[serde(with = "ts_seconds")]
pub timestamp_ended: DateTime<Utc>,
#[serde(deserialize_with = "de_util::empty_string_int_option")]
pub attacker_id: Option<i32>,
#[serde(deserialize_with = "de_util::empty_string_is_none")]
pub attacker_name: Option<&'a str>,
#[serde(deserialize_with = "de_util::empty_string_int_option")]
pub attacker_faction: Option<i32>,
#[serde(
deserialize_with = "de_util::empty_string_is_none",
rename = "attacker_factionname"
)]
pub attacker_faction_name: Option<&'a str>,
pub defender_id: i32,
pub defender_name: &'a str,
#[serde(deserialize_with = "de_util::empty_string_int_option")]
pub defender_faction: Option<i32>,
#[serde(
deserialize_with = "de_util::empty_string_is_none",
rename = "defender_factionname"
)]
pub defender_faction_name: Option<&'a str>,
pub result: AttackResult,
#[serde(deserialize_with = "de_util::int_is_bool")]
pub stealthed: bool,
#[serde(deserialize_with = "de_util::int_is_bool")]
pub raid: bool,
#[serde(deserialize_with = "de_util::int_is_bool")]
pub ranked_war: bool,
#[cfg(feature = "decimal")]
pub respect: rust_decimal::Decimal,
#[cfg(feature = "decimal")]
pub respect_loss: rust_decimal::Decimal,
#[cfg(not(feature = "decimal"))]
pub respect: f32,
#[cfg(not(feature = "decimal"))]
pub respect_loss: f32,
pub modifiers: RespectModifiers,
}
#[cfg(test)]
@ -47,10 +163,12 @@ mod tests {
let response = Client::default()
.torn_api(key)
.faction(|b| b.selections(&[Selection::Basic]))
.faction(|b| b.selections(&[Selection::Basic, Selection::Attacks]))
.await
.unwrap();
response.basic().unwrap();
response.attacks().unwrap();
response.attacks_full().unwrap();
}
}

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

@ -1,23 +1,32 @@
#![warn(clippy::all, clippy::perf, clippy::style, clippy::suspicious)]
pub mod faction;
pub mod local;
pub mod send;
pub mod torn;
#[cfg(feature = "user")]
pub mod user;
#[cfg(feature = "faction")]
pub mod faction;
#[cfg(feature = "torn")]
pub mod torn;
#[cfg(feature = "awc")]
pub mod awc;
#[cfg(feature = "reqwest")]
pub mod reqwest;
#[cfg(feature = "__common")]
mod common;
mod de_util;
use std::fmt::Write;
use chrono::{DateTime, Utc};
use serde::de::{DeserializeOwned, Error as DeError};
use serde::{de::Error as DeError, Deserialize};
use thiserror::Error;
pub struct ApiResponse {
@ -53,16 +62,18 @@ impl ApiResponse {
}
}
fn decode<D>(&self) -> serde_json::Result<D>
#[allow(dead_code)]
fn decode<'de, D>(&'de self) -> serde_json::Result<D>
where
D: DeserializeOwned,
D: Deserialize<'de>,
{
D::deserialize(&self.value)
}
fn decode_field<D>(&self, field: &'static str) -> serde_json::Result<D>
#[allow(dead_code)]
fn decode_field<'de, D>(&'de self, field: &'static str) -> serde_json::Result<D>
where
D: DeserializeOwned,
D: Deserialize<'de>,
{
self.value
.get(field)
@ -70,6 +81,7 @@ impl ApiResponse {
.and_then(D::deserialize)
}
#[allow(dead_code)]
fn decode_field_with<'de, V, F>(&'de self, field: &'static str, fun: F) -> serde_json::Result<V>
where
F: FnOnce(&'de serde_json::Value) -> serde_json::Result<V>,
@ -236,6 +248,7 @@ where
}
#[cfg(test)]
#[allow(unused)]
pub(crate) mod tests {
use std::sync::Once;
@ -265,12 +278,13 @@ pub(crate) mod tests {
std::env::var("APIKEY").expect("api key")
}
#[cfg(feature = "user")]
#[test]
fn selection_raw_value() {
assert_eq!(user::Selection::Basic.raw_value(), "basic");
}
#[cfg(feature = "reqwest")]
#[cfg(all(feature = "reqwest", feature = "user"))]
#[tokio::test]
async fn reqwest() {
let key = setup();
@ -278,15 +292,11 @@ pub(crate) mod tests {
Client::default().torn_api(key).user(|b| b).await.unwrap();
}
#[cfg(feature = "awc")]
#[cfg(all(feature = "awc", feature = "user"))]
#[actix_rt::test]
async fn awc() {
let key = setup();
Client::default()
.torn_api(key)
.user(None, |b| b)
.await
.unwrap();
Client::default().torn_api(key).user(|b| b).await.unwrap();
}
}

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

@ -2,17 +2,16 @@ use std::collections::HashMap;
use async_trait::async_trait;
use crate::{
faction, torn, user, ApiCategoryResponse, ApiClientError, ApiRequest, ApiRequestBuilder,
ApiResponse, DirectExecutor,
};
use crate::{ApiCategoryResponse, ApiClientError, ApiRequest, ApiResponse, DirectExecutor};
pub struct ApiProvider<'a, C, E>
where
C: ApiClient,
E: RequestExecutor<C>,
{
#[allow(dead_code)]
client: &'a C,
#[allow(dead_code)]
executor: E,
}
@ -25,11 +24,14 @@ where
Self { client, executor }
}
pub async fn user<F>(&self, build: F) -> Result<user::Response, E::Error>
#[cfg(feature = "user")]
pub async fn user<F>(&self, build: F) -> Result<crate::user::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::user::Response>,
) -> crate::ApiRequestBuilder<crate::user::Response>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -37,18 +39,21 @@ where
.await
}
#[cfg(feature = "user")]
pub async fn users<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<user::Response, E::Error>>
) -> HashMap<I, Result<crate::user::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::user::Response>,
) -> crate::ApiRequestBuilder<crate::user::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -63,11 +68,14 @@ where
.collect()
}
pub async fn faction<F>(&self, build: F) -> Result<faction::Response, E::Error>
#[cfg(feature = "faction")]
pub async fn faction<F>(&self, build: F) -> Result<crate::faction::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::faction::Response>,
) -> crate::ApiRequestBuilder<crate::faction::Response>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -75,18 +83,21 @@ where
.await
}
#[cfg(feature = "faction")]
pub async fn factions<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<faction::Response, E::Error>>
) -> HashMap<I, Result<crate::faction::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::faction::Response>,
) -> crate::ApiRequestBuilder<crate::faction::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -101,11 +112,14 @@ where
.collect()
}
pub async fn torn<F>(&self, build: F) -> Result<torn::Response, E::Error>
#[cfg(feature = "torn")]
pub async fn torn<F>(&self, build: F) -> Result<crate::torn::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::torn::Response>,
) -> crate::ApiRequestBuilder<crate::torn::Response>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -113,18 +127,21 @@ where
.await
}
#[cfg(feature = "torn")]
pub async fn torns<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<torn::Response, E::Error>>
) -> HashMap<I, Result<crate::torn::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::torn::Response>,
) -> crate::ApiRequestBuilder<crate::torn::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor

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

@ -2,17 +2,16 @@ use std::collections::HashMap;
use async_trait::async_trait;
use crate::{
faction, torn, user, ApiCategoryResponse, ApiClientError, ApiRequest, ApiRequestBuilder,
ApiResponse, DirectExecutor,
};
use crate::{ApiCategoryResponse, ApiClientError, ApiRequest, ApiResponse, DirectExecutor};
pub struct ApiProvider<'a, C, E>
where
C: ApiClient,
E: RequestExecutor<C>,
{
#[allow(dead_code)]
client: &'a C,
#[allow(dead_code)]
executor: E,
}
@ -25,11 +24,14 @@ where
Self { client, executor }
}
pub async fn user<F>(&self, build: F) -> Result<user::Response, E::Error>
#[cfg(feature = "user")]
pub async fn user<F>(&self, build: F) -> Result<crate::user::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::user::Response>,
) -> crate::ApiRequestBuilder<crate::user::Response>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -37,18 +39,21 @@ where
.await
}
#[cfg(feature = "user")]
pub async fn users<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<user::Response, E::Error>>
) -> HashMap<I, Result<crate::user::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::user::Response>,
) -> crate::ApiRequestBuilder<crate::user::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -63,11 +68,14 @@ where
.collect()
}
pub async fn faction<F>(&self, build: F) -> Result<faction::Response, E::Error>
#[cfg(feature = "faction")]
pub async fn faction<F>(&self, build: F) -> Result<crate::faction::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::faction::Response>,
) -> crate::ApiRequestBuilder<crate::faction::Response>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -75,18 +83,21 @@ where
.await
}
#[cfg(feature = "faction")]
pub async fn factions<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<faction::Response, E::Error>>
) -> HashMap<I, Result<crate::faction::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::faction::Response>,
) -> crate::ApiRequestBuilder<crate::faction::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -101,11 +112,14 @@ where
.collect()
}
pub async fn torn<F>(&self, build: F) -> Result<torn::Response, E::Error>
#[cfg(feature = "torn")]
pub async fn torn<F>(&self, build: F) -> Result<crate::torn::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::torn::Response>,
) -> crate::ApiRequestBuilder<crate::torn::Response>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -113,18 +127,21 @@ where
.await
}
#[cfg(feature = "torn")]
pub async fn torns<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<torn::Response, E::Error>>
) -> HashMap<I, Result<crate::torn::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
F: FnOnce(
crate::ApiRequestBuilder<crate::torn::Response>,
) -> crate::ApiRequestBuilder<crate::torn::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::default();
let mut builder = crate::ApiRequestBuilder::default();
builder = build(builder);
self.executor

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

@ -46,6 +46,20 @@ where
formatter.write_str("struct Competition")
}
fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: serde::Deserializer<'de>,
{
deserializer.deserialize_map(self)
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
where
V: MapAccess<'de>,
@ -77,7 +91,7 @@ where
}
}
deserializer.deserialize_map(CompetitionVisitor)
deserializer.deserialize_option(CompetitionVisitor)
}
#[cfg(test)]

112
torn-api/src/user.rs
View file

@ -1,4 +1,3 @@
use chrono::{serde::ts_seconds, DateTime, Utc};
use serde::{
de::{self, MapAccess, Visitor},
Deserialize, Deserializer,
@ -6,7 +5,9 @@ use serde::{
use torn_api_macros::ApiCategory;
use super::de_util;
use crate::de_util;
pub use crate::common::{LastAction, Status};
#[derive(Debug, Clone, Copy, ApiCategory)]
#[api(category = "user")]
@ -30,22 +31,16 @@ pub enum Gender {
Enby,
}
#[derive(Debug, Clone, Deserialize)]
pub struct LastAction {
#[serde(with = "ts_seconds")]
pub timestamp: DateTime<Utc>,
}
#[derive(Debug, Clone)]
pub struct Faction {
pub struct Faction<'a> {
pub faction_id: i32,
pub faction_name: String,
pub faction_name: &'a str,
pub days_in_faction: i16,
pub position: String,
pub faction_tag: Option<String>,
pub position: &'a str,
pub faction_tag: Option<&'a str>,
}
fn deserialize_faction<'de, D>(deserializer: D) -> Result<Option<Faction>, D::Error>
fn deserialize_faction<'de, D>(deserializer: D) -> Result<Option<Faction<'de>>, D::Error>
where
D: Deserializer<'de>,
{
@ -62,7 +57,7 @@ where
struct FactionVisitor;
impl<'de> Visitor<'de> for FactionVisitor {
type Value = Option<Faction>;
type Value = Option<Faction<'de>>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Faction")
@ -128,44 +123,13 @@ where
deserializer.deserialize_struct("Faction", FIELDS, FactionVisitor)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
pub enum State {
Okay,
Traveling,
Hospital,
Abroad,
Jail,
Federal,
Fallen,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum StateColour {
Green,
Red,
Blue,
}
#[derive(Debug, Clone, Deserialize)]
pub struct Status {
pub description: String,
#[serde(deserialize_with = "de_util::empty_string_is_none")]
pub details: Option<String>,
#[serde(rename = "color")]
pub colour: StateColour,
pub state: State,
#[serde(deserialize_with = "de_util::zero_date_is_none")]
pub until: Option<DateTime<Utc>>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct Basic {
pub struct Basic<'a> {
pub player_id: i32,
pub name: String,
pub name: &'a str,
pub level: i16,
pub gender: Gender,
pub status: Status,
pub status: Status<'a>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
@ -238,6 +202,20 @@ where
formatter.write_str("struct Competition")
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_map(self)
}
fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
where
V: MapAccess<'de>,
@ -259,11 +237,11 @@ where
attacks = Some(map.next_value()?);
}
Field::Team => {
let team_raw: String = map.next_value()?;
let team_raw: &str = map.next_value()?;
team = if team_raw.is_empty() {
None
} else {
Some(match team_raw.as_str() {
Some(match team_raw {
"firestarters" => EliminationTeam::Firestarters,
"hard-boiled" => EliminationTeam::HardBoiled,
"quack-addicts" => EliminationTeam::QuackAddicts,
@ -277,7 +255,7 @@ where
"wolf-pack" => EliminationTeam::WolfPack,
"sleepyheads" => EliminationTeam::Sleepyheads,
_ => Err(de::Error::unknown_variant(
&team_raw,
team_raw,
&[
"firestarters",
"hard-boiled",
@ -320,14 +298,14 @@ where
}
}
deserializer.deserialize_map(CompetitionVisitor)
deserializer.deserialize_option(CompetitionVisitor)
}
#[derive(Debug, Clone, Deserialize)]
pub struct Profile {
pub struct Profile<'a> {
pub player_id: i32,
pub name: String,
pub rank: String,
pub name: &'a str,
pub rank: &'a str,
pub level: i16,
pub gender: Gender,
pub age: i32,
@ -335,8 +313,8 @@ pub struct Profile {
pub life: LifeBar,
pub last_action: LastAction,
#[serde(deserialize_with = "deserialize_faction")]
pub faction: Option<Faction>,
pub status: Status,
pub faction: Option<Faction<'a>>,
pub status: Status<'a>,
#[serde(deserialize_with = "deserialize_comp")]
pub competition: Option<Competition>,
@ -436,20 +414,6 @@ mod tests {
assert!(faction.is_none());
}
#[async_test]
async fn team_visible() {
let key = setup();
let response = Client::default()
.torn_api(key)
.user(|b| b.selections(&[Selection::Profile]))
.await
.unwrap();
let profile = response.profile().unwrap();
assert!(profile.competition.is_some());
}
#[async_test]
async fn bulk() {
let key = setup();
@ -469,14 +433,12 @@ mod tests {
async fn discord() {
let key = setup();
let basic = Client::default()
let response = Client::default()
.torn_api(key)
.user(|b| b.id(374272176892674048i64).selections(&[Selection::Basic]))
.await
.unwrap()
.basic()
.unwrap();
assert_eq!(basic.player_id, 2111649);
assert_eq!(response.basic().unwrap().player_id, 2111649);
}
}