as-rust/exchanges/src/http_tool.rs

use reqwest::{Client};
use reqwest::header::HeaderMap;
use tracing::trace;
use crate::response_base::ResponseData;
#[derive(Clone)]
pub struct RestTool {
    pub base_url: String,
    client: Client,
}

impl RestTool {
    pub fn new(base_url: String) -> RestTool {
        RestTool { base_url, client: Client::new() }
    }
    pub async fn http_toll(&self, request_path: String, request_type: String, params: String, headers: HeaderMap) -> Result<ResponseData, reqwest::Error> {
        let res_data: ResponseData;
        /****请求接口与 地址*/
        let url = format!("{}{}", self.base_url.to_string(), request_path);
        let request_type = request_type.clone().to_uppercase();
        let addrs_url = format!("{}?{}", url.clone(), RestTool::parse_params_to_str(params.clone()));
        // let params_json: serde_json::Value = serde_json::from_str(&params).unwrap();
        // trace!("url:{}",url);
        // trace!("addrs_url:{}",url);
        // trace!("params_json:{}",params_json);
        // trace!("headers:{:?}",headers);

        let req = match request_type.as_str() {
            "GET" => self.client.get(addrs_url.clone()).headers(headers),
            "POST" => self.client.post(addrs_url.clone()).body(params).headers(headers),
            "DELETE" => self.client.delete(addrs_url.clone()).headers(headers),
            // "PUT" => self.client.put(url.clone()).json(&params),
            _ => return Ok(ResponseData::error("".to_string(),format!("错误的请求类型:{}", request_type.clone()))), // 处理未知请求类型
        };

        let response = req.send().await?;
        if response.status().is_success() {
            // 读取响应的内容
            let body = response.text().await?;
            // trace!("ok-----{}", body);
            res_data = ResponseData::new("".to_string(),"200".to_string(), "success".to_string(), body);
        } else {
            let body = response.text().await?;
            // trace!("error-----{}", body);
            res_data = ResponseData::error("".to_string(),body.to_string())
        }
        Ok(res_data)
    }

    //map数据转 get请求参数
    pub fn parse_params_to_str(parameters: String) -> String {
        let mut params_str = String::from("");
        let parsed_json: serde_json::Value = serde_json::from_str(&parameters).unwrap();

        if let Some(json_obj) = parsed_json.as_object() {
            for (key, value) in json_obj.iter() {
                let formatted_value = match value {
                    serde_json::Value::String(s) => s.clone(),
                    _ => value.to_string()
                };
                // trace!("Key: {}", key);
                // trace!("Value: {}", formatted_value);
                // let formatted_value = match value {
                //     Value::String(s) => s.clone(),
                //     _ => value.to_string()
                // };
                let str = format!("{}={}", key, formatted_value);
                let format_str = format!("{}{}{}", params_str, (if params_str.len() > 0 { "&" } else { "" }), str);
                params_str = format_str;
            }
        }
        trace!("---json-转字符串拼接:{}",params_str);
        params_str.to_string()
    }
    //res_data 解析
    pub fn res_data_analysis(result: Result<ResponseData, reqwest::Error>) -> ResponseData {
        match result {
            Ok(res_data) => {
                if res_data.code != "0" {
                    res_data
                } else {
                    let body: String = res_data.data;
                    let json_value: serde_json::Value = serde_json::from_str(&body).unwrap();

                    let code = json_value["code"].as_str().unwrap();
                    let data = serde_json::to_string(&json_value["data"]).unwrap();
                    let msg = json_value["msg"].as_str().unwrap();

                    // //trace!("--解析成功----code:{}",code);
                    // //trace!("--解析成功----data:{}",data);
                    // //trace!("--解析成功----msg:{}",msg);
                    let success = ResponseData::new("".to_string(),
                                                    code.parse().unwrap(),
                                                    msg.parse().unwrap(),
                                                    data.parse().unwrap());
                    success
                }
            }
            Err(err) => {
                let error = ResponseData::error("".to_string(),format!("json 解析失败:{}", err));
                error
            }
        }
    }
}