pnwkit 3.0.0-alpha.15

pnwkit bindings for Rust.
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

use std::sync::{Arc, Mutex};

#[cfg(feature = "async")]
use std::{future::Future, pin::Pin};

use pnwkit_core::{Headers, Kit, RateLimiter};

use crate::client::Client;

#[cfg(feature = "subscriptions")]
use crate::socket::Socket;

#[cfg(feature = "async")]
fn sleep(duration: std::time::Duration) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>> {
    Box::pin(tokio::time::sleep(duration))
}

pub struct Config {
    pub api_key: String,
    pub verified_bot_key: Option<String>,
    pub verified_bot_key_api_key: Option<String>,
    pub api_url: String,
    #[cfg(feature = "subscriptions")]
    pub socket_url: String,
    #[cfg(feature = "subscriptions")]
    pub subscribe_url: String,
    #[cfg(feature = "subscriptions")]
    pub subscription_auth_url: String,
}

impl Config {
    pub fn new() -> Self {
        Config {
            api_key: String::new(),
            verified_bot_key: None,
            verified_bot_key_api_key: None,
            api_url: "https://api.politicsandwar.com/graphql".into(),
            #[cfg(feature = "subscriptions")]
            socket_url: "wss://socket.politicsandwar.com/app/a22734a47847a64386c8?protocol=7"
                .into(),
            #[cfg(feature = "subscriptions")]
            subscribe_url:
                "https://api.politicsandwar.com/subscriptions/v1/subscribe/{model}/{event}".into(),
            #[cfg(feature = "subscriptions")]
            subscription_auth_url: "https://api.politicsandwar.com/subscriptions/v1/auth".into(),
        }
    }

    pub fn set_api_key(mut self, api_key: String) -> Self {
        self.api_key = api_key;
        self
    }

    pub fn set_verified_bot_key(mut self, verified_bot_key: String) -> Self {
        self.verified_bot_key = Some(verified_bot_key);
        self
    }

    pub fn set_verified_bot_key_api_key(mut self, verified_bot_key_api_key: String) -> Self {
        self.verified_bot_key_api_key = Some(verified_bot_key_api_key);
        self
    }

    pub fn set_api_url(mut self, api_url: String) -> Self {
        self.api_url = api_url;
        self
    }

    #[cfg(feature = "subscriptions")]
    pub fn set_socket_url(mut self, socket_url: String) -> Self {
        self.socket_url = socket_url;
        self
    }

    #[cfg(feature = "subscriptions")]
    pub fn set_subscribe_url(mut self, subscriptions_url: String) -> Self {
        self.subscribe_url = subscriptions_url;
        self
    }

    #[cfg(feature = "subscriptions")]
    pub fn set_subscription_auth_url(mut self, subscription_auth_url: String) -> Self {
        self.subscription_auth_url = subscription_auth_url;
        self
    }

    pub fn to_kit(self) -> Kit {
        let now = || {
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs()
        };
        let config = pnwkit_core::Config {
            api_key: self.api_key,
            verified_bot_key: self.verified_bot_key,
            verified_bot_key_api_key: self.verified_bot_key_api_key,
            api_url: self.api_url,
            #[cfg(feature = "subscriptions")]
            socket_url: self.socket_url,
            #[cfg(feature = "subscriptions")]
            subscribe_url: self.subscribe_url,
            #[cfg(feature = "subscriptions")]
            subscription_auth_url: self.subscription_auth_url,
            rate_limiter: Arc::new(Mutex::new(RateLimiter::new(now))),
            #[cfg(feature = "subscriptions")]
            socket: Box::new(Socket::new()),
            client: Box::new(Client::new()),
            headers: Headers::new(),
            now,
            #[cfg(feature = "async")]
            sleep,
            #[cfg(feature = "sync")]
            sleep_sync: std::thread::sleep,
            user_agent: format!("pnwkit-rs/{}", env!("CARGO_PKG_VERSION")),
        }
        .update_headers();
        Kit::new(config)
    }
}

impl Default for Config {
    fn default() -> Self {
        Self::new()
    }
}