bw-web-api-rs 0.2.8

A Rust client for the StarCraft: Remastered 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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use serde::Serialize;

use crate::endpoints::Endpoint;
use crate::error::ApiError;
use crate::models::{ScrMmGameLoading, ScrMmToonInfo, ScrProfile, ScrToonInfo};
use crate::types::Gateway;

#[derive(Debug, Clone, Copy, Serialize)]
pub enum AuroraProfileFieldMask {
    #[serde(rename = "scr_profile")]
    ScrProfile,
    #[serde(rename = "scr_mmgameloading")]
    ScrMmGameLoading,
    #[serde(rename = "scr_mmtooninfo")]
    ScrMmToonInfo,
    #[serde(rename = "scr_tooninfo")]
    ScrToonInfo,
}

pub struct AuroraProfileEndpoint {
    toon: String,
    gateway: Gateway,
    field_mask: AuroraProfileFieldMask,
}

impl AuroraProfileEndpoint {
    pub fn new(toon: String, gateway: Gateway, field_mask: AuroraProfileFieldMask) -> Self {
        Self {
            toon,
            gateway,
            field_mask,
        }
    }
}

impl Endpoint for AuroraProfileEndpoint {
    type Request = ();
    type Response = serde_json::Value;

    fn endpoint(&self) -> String {
        format!(
            "/web-api/v2/aurora-profile-by-toon/{}/{}?request_flags={}",
            urlencoding::encode(&self.toon),
            self.gateway as i32,
            match self.field_mask {
                AuroraProfileFieldMask::ScrProfile => "scr_profile",
                AuroraProfileFieldMask::ScrMmGameLoading => "scr_mmgameloading",
                AuroraProfileFieldMask::ScrMmToonInfo => "scr_mmtooninfo",
                AuroraProfileFieldMask::ScrToonInfo => "scr_tooninfo",
            }
        )
    }

    fn validate_response(response: &serde_json::Value) -> Result<(), ApiError> {
        if let Some(aurora_id) = response.get("aurora_id") {
            if aurora_id == 0 {
                return Err(ApiError::ValidationError("Profile not found".to_string()));
            }
        }
        Ok(())
    }
}

impl crate::client::ApiClient {
    /// Get aurora profile with scr_profile flag
    ///
    /// Endpoint: /web-api/v2/aurora-profile-by-toon/{toon}/{gateway}?request_flags=scr_profile
    pub async fn get_aurora_profile_by_toon_scr_profile(
        &self,
        toon: String,
        gateway: Gateway,
    ) -> Result<ScrProfile, ApiError> {
        let endpoint =
            AuroraProfileEndpoint::new(toon, gateway, AuroraProfileFieldMask::ScrProfile);
        let json = self.request(&endpoint, &()).await?;

        AuroraProfileEndpoint::validate_response(&json)?;
        serde_json::from_value(json).map_err(Into::into)
    }

    /// Get aurora profile with scr_mmgameloading flag
    ///
    /// Endpoint: /web-api/v2/aurora-profile-by-toon/{toon}/{gateway}?request_flags=scr_mmgameloading
    pub async fn get_aurora_profile_by_toon_mm_game_loading(
        &self,
        toon: String,
        gateway: Gateway,
    ) -> Result<ScrMmGameLoading, ApiError> {
        let endpoint =
            AuroraProfileEndpoint::new(toon, gateway, AuroraProfileFieldMask::ScrMmGameLoading);
        let json = self.request(&endpoint, &()).await?;

        AuroraProfileEndpoint::validate_response(&json)?;
        serde_json::from_value(json).map_err(Into::into)
    }

    /// Get aurora profile with scr_mmtooninfo flag
    ///
    /// Endpoint: /web-api/v2/aurora-profile-by-toon/{toon}/{gateway}?request_flags=scr_mmtooninfo
    pub async fn get_aurora_profile_by_toon_mm_toon_info(
        &self,
        toon: String,
        gateway: Gateway,
    ) -> Result<ScrMmToonInfo, ApiError> {
        let endpoint =
            AuroraProfileEndpoint::new(toon, gateway, AuroraProfileFieldMask::ScrMmToonInfo);
        let json = self.request(&endpoint, &()).await?;

        AuroraProfileEndpoint::validate_response(&json)?;
        serde_json::from_value(json).map_err(Into::into)
    }

    /// Get aurora profile with scr_tooninfo flag
    ///
    /// Endpoint: /web-api/v2/aurora-profile-by-toon/{toon}/{gateway}?request_flags=scr_tooninfo
    pub async fn get_aurora_profile_by_toon_toon_info(
        &self,
        toon: String,
        gateway: Gateway,
    ) -> Result<ScrToonInfo, ApiError> {
        let endpoint =
            AuroraProfileEndpoint::new(toon, gateway, AuroraProfileFieldMask::ScrToonInfo);
        let json = self.request(&endpoint, &()).await?;

        AuroraProfileEndpoint::validate_response(&json)?;
        serde_json::from_value(json).map_err(Into::into)
    }
}