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

use crate::api_clients::errors::ApiCallError;
use crossterm::style::Stylize;

pub enum RestApiCallType {
    Get,
    Post,
}

pub async fn execute_request<Req: serde::Serialize, Res: serde::de::DeserializeOwned>(
    url: String,
    rest_api_call_type: RestApiCallType,
    token: Option<String>,
    request_body: Option<Req>,
    additional_headers: Vec<(String, String)>,
) -> Result<Res, ApiCallError> {
    let client = reqwest::Client::new();
    let mut response = match rest_api_call_type {
        RestApiCallType::Get => client.get(url),
        RestApiCallType::Post => client.post(url),
    };
    if let Some(token) = token {
        response = response.header("Authorization", format!("Bearer {}", token));
    }
    for additional_header in additional_headers {
        response = response.header(additional_header.0, additional_header.1);
    }
    let response = match request_body {
        Some(request_body) => response.json(&request_body).send().await,
        None => response.send().await,
    };
    match response {
        Ok(response) => map_response(response.json().await),
        Err(error) => Err(ApiCallError::RequestFailed(error.to_string())),
    }
}

pub async fn execute_request_and_log<Req: serde::Serialize>(
    url: String,
    rest_api_call_type: RestApiCallType,
    token: Option<String>,
    request_body: Option<Req>,
    additional_headers: Vec<(String, String)>,
) -> Result<(), ApiCallError> {
    let client = reqwest::Client::new();
    let mut response = match rest_api_call_type {
        RestApiCallType::Get => client.get(url),
        RestApiCallType::Post => client.post(url),
    };
    if let Some(token) = token {
        response = response.header("Authorization", format!("Bearer {}", token));
    }
    for additional_header in additional_headers {
        response = response.header(additional_header.0, additional_header.1);
    }
    match request_body {
        Some(request_body) => {
            let r = response.json(&request_body).send().await;
            match r {
                Ok(r) => {
                    println!("{}", "Status:".red());
                    println!("    {}", r.status());
                    println!("{}", "Headers:".red());
                    for x in r.headers() {
                        if let Ok(value) = x.1.to_str() {
                            println!("    {} - {}", x.0, value);
                        }
                    }
                    if let Ok(body) = r.text().await {
                        println!("{}", "Body:".red());
                        println!("    {}", body);
                    }
                }
                Err(e) => {
                    println!("Error: {}", e);
                }
            }
        }
        None => {
            let r = response.send().await;
            match r {
                Ok(r) => {
                    println!("{}", "Status:".red());
                    println!("    {}", r.status());
                    println!("{}", "Headers:".red());
                    for x in r.headers() {
                        if let Ok(value) = x.1.to_str() {
                            println!("    {} - {}", x.0, value);
                        }
                    }
                    if let Ok(body) = r.text().await {
                        println!("{}", "Body:".red());
                        println!("    {}", body);
                    }
                }
                Err(e) => {
                    println!("Error: {}", e);
                }
            }
        }
    };
    Ok(())
}

fn map_response<Res: serde::de::DeserializeOwned>(
    response: reqwest::Result<Res>,
) -> Result<Res, ApiCallError> {
    match response {
        Ok(response) => Ok(response),
        Err(error) => Err(ApiCallError::JsonParse(error.to_string())),
    }
}