auraxis 0.3.0

API & ESS client for Planetside 2 Census API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use reqwest::Response;
use serde::{de::IgnoredAny, de::Visitor, Deserialize};

use crate::AuraxisError;

#[derive(Debug)]
pub struct CensusResponse {
    pub items: Vec<serde_json::Value>,
    pub count: u32,
}

impl<'de> Deserialize<'de> for CensusResponse {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_map(CensusResponseVisitor)
    }
}

struct CensusResponseVisitor;

impl<'de> Visitor<'de> for CensusResponseVisitor {
    type Value = CensusResponse;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(
            formatter,
            "a map with keys '<collection>_list>' and 'returned'"
        )
    }

    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
    where
        A: serde::de::MapAccess<'de>,
    {
        let mut items = None;
        let mut count = None;

        while let Some(k) = map.next_key::<&str>()? {
            if k == "returned" {
                count = Some(map.next_value()?);
            } else if k.ends_with("_list") {
                items = Some(map.next_value()?);
            } else {
                let _ = map.next_value::<IgnoredAny>()?;
            }
        }

        let items =
            items.ok_or_else(|| serde::de::Error::custom("Missing collection_list or count"))?;
        let count =
            count.ok_or_else(|| serde::de::Error::custom("Missing collection_list or count"))?;

        Ok(CensusResponse { items, count })
    }
}

impl CensusResponse {
    pub async fn from_response(response: Response) -> Result<Self, AuraxisError> {
        Ok(response.json::<CensusResponse>().await?)
    }
}

#[cfg(test)]
mod tests {
    use super::CensusResponse;

    #[test]
    fn ignores_extra_metadata_keys() {
        let response = serde_json::from_str::<CensusResponse>(
            r#"{
                "character_list": [{"character_id": "1"}],
                "returned": 1,
                "timing": {"query": "1.23"},
                "errorCode": "ok"
            }"#,
        )
        .expect("response should deserialize");

        assert_eq!(response.count, 1);
        assert_eq!(response.items.len(), 1);
    }
}