as-rust/exchanges/src/http_tool.rs

use tracing::trace;
use crate::response_base::ResponseData;

#[derive(Clone)]
pub struct RestTool {
    pub base_url: String
}

impl RestTool {
    pub fn new(base_url: String) -> RestTool {
        RestTool { base_url }
    }

    // pub async fn http_tool(&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 json_value= res_data.data;

                    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
            }
        }
    }
}