vtg 1.1.2

Library for creating VK and Telegram bots
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

use std::borrow::Cow;

use log::debug;
use serde_json::Value;

use crate::structs::{context::Platform, struct_to_vec::param};

use super::*;
/// Send request to VK or Telegram API
/// # Arguments
/// * `platform` - Platform to send request to
/// * `method` - Method to call
/// * `params` - Parameters to send
/// * `config` - Config to use
///
/// # Returns
/// * `Result<Value, String>` - Response from API
///
/// # Examples
/// ```no_run
/// use vtg::client::api_requests::api_call;
/// use vtg::structs::{context::Platform, struct_to_vec::param};
///
/// let response = api_call(Platform::VK, "messages.send", vec![param("peer_id", "1"), param("message", "Hello, world!")], &config).await;
/// match response {
///   Ok(response) => {
///      println!("Response: {}", response);
///   }
///   Err(e) => {
///      println!("Error: {}", e);
///   }
///}
/// ```
pub async fn api_call(
    platform: Platform,
    method: &str,
    mut params: Vec<(Cow<'_, str>, Cow<'_, str>)>,
    config: &Config,
) -> Result<Value, String> {
    let url = match platform {
        Platform::VK => format!("https://api.vk.com/method/{}", method),
        Platform::Telegram => format!(
            "https://api.telegram.org/{}/{}",
            config.tg_access_token, method
        ),
    };
    let access_token = match platform {
        Platform::VK => config.vk_access_token.clone(),
        Platform::Telegram => "".to_owned(),
    };
    if platform == Platform::VK {
        params.push(param("v", &config.vk_api_version));
    }
    let response = request(&url, &access_token, params).await;
    match response {
        Ok(response_text) => {
            debug!("API call response text: {}", response_text);
            let response_json: serde_json::Value =
                serde_json::from_str(&response_text).map_err(|e| e.to_string())?;
            match platform {
                Platform::VK => {
                    if let Some(error) = response_json.get("error") {
                        let error_msg = error["error_msg"].as_str().unwrap_or("Unknown error");
                        Err(error_msg.to_string())
                    } else {
                        Ok(response_json)
                    }
                }
                Platform::Telegram => {
                    if let Some(ok) = response_json.get("ok") {
                        if ok.as_bool().unwrap_or(false) {
                            Ok(response_json)
                        } else {
                            let error_msg = response_json["description"]
                                .as_str()
                                .unwrap_or("Unknown error");
                            Err(error_msg.to_string())
                        }
                    } else {
                        Err("Invalid response from Telegram API".to_string())
                    }
                }
            }
        }
        Err(_) => Err("Error while sending request".to_string()),
    }
}