as-rust/exchanges/src/bitget_swap_rest.rs

use std::collections::BTreeMap;
use std::str::FromStr;
use reqwest::Client;
use reqwest::header::HeaderMap;
use rust_decimal::Decimal;
use tracing::info;
use crate::http_tool::RestTool;
use crate::response_base::ResponseData;
use ring::hmac;
use rust_decimal::prelude::FromPrimitive;
use serde_json::Value;

#[derive(Clone, Debug)]
pub struct BitgetSwapRest {
    pub label: String,
    base_url: String,
    client: Client,
    login_param: BTreeMap<String, String>,                  // 登录参数
    delays: Vec<i64>,
    max_delay: i64,
    avg_delay: Decimal,
}

impl BitgetSwapRest {
    pub fn new(is_colo: bool, login_param: BTreeMap<String, String>) -> BitgetSwapRest {
        return BitgetSwapRest::new_label("default-BitgetSwapRest".to_string(), is_colo, login_param)
    }

    // 构造Bitget，可以自定义label
    pub fn new_label(label: String, is_colo: bool, login_param: BTreeMap<String, String>) -> BitgetSwapRest {
        let base_url = if is_colo {
            "https://api.bitget.com".to_string()
        } else {
            "https://api.bitget.com".to_string()
        };

        if is_colo {
            info!("开启高速(未配置，走普通：{})通道", base_url);
        } else {
            info!("走普通通道：{}", base_url);
        }

        BitgetSwapRest {
            label,
            base_url,
            client: Client::new(),
            login_param,
            delays: vec![],
            max_delay: 0,
            avg_delay: Decimal::ZERO,
        }
    }

    //获取行情信息
    pub async fn get_contracts(&mut self, symbol: String) -> ResponseData {
        let params = serde_json::json!({
            "symbol": symbol,
            "productType": "USDT-FUTURES"
         });
        let data = self.request("GET".to_string(),
                                "/api/v2".to_string(),
                                "/mix/market/contracts".to_string(),
                                true,
                                params.to_string(),
        ).await;
        data
    }

    //获取行情信息
    pub async fn get_tickers(&mut self, symbol: String) -> ResponseData {
        let params = serde_json::json!({
            "symbol": symbol,
            "productType": "USDT-FUTURES"
         });
        let data = self.request("GET".to_string(),
                                "/api/v2".to_string(),
                                "/mix/market/ticker".to_string(),
                                true,
                                params.to_string(),
        ).await;
        data
    }

    // 获取服务器时间
    pub async fn get_server_time(&mut self) -> ResponseData {
        let params = serde_json::json!({});
        self.request("GET".to_string(),
                     "/api/v2".to_string(),
                     "/public/time".to_string(),
                     false,
                     params.to_string(),
        ).await
    }

    // 获取账户信息
    pub async fn get_account_info(&mut self) -> ResponseData {
        let params = serde_json::json!({
            "productType": "USDT-FUTURES"
        });

        self.request("GET".to_string(),
                     "/api/v2".to_string(),
                     "/mix/account/accounts".to_string(),
                     true,
                     params.to_string(),
        ).await
    }

    // 获取仓位信息（单个）
    pub async fn get_single_position(&mut self, params: Value) -> ResponseData {
        self.request("GET".to_string(),
                     "/api/v2".to_string(),
                     "/mix/position/single-position".to_string(),
                     true,
                     params.to_string(),
        ).await
    }

    // 获取所有仓位
    pub async fn get_all_position(&mut self, params: Value) -> ResponseData {
        self.request("GET".to_string(),
                     "/api/v2".to_string(),
                     "/mix/position/all-position".to_string(),
                     true,
                     params.to_string(),
        ).await
    }

    // 获取K线
    pub async fn get_market_candles(&mut self, params: Value) -> ResponseData {
        self.request("GET".to_string(),
                     "/api/v2".to_string(),
                     "/mix/market/candles".to_string(),
                     true,
                     params.to_string(),
        ).await
    }

    // 下单
    pub async fn swap_order(&mut self, params: Value) -> ResponseData {
        self.request("POST".to_string(),
                     "/api/v2".to_string(),
                     "/mix/order/place-order".to_string(),
                     true,
                     params.to_string(),
        ).await
    }

    // 撤单
    pub async fn cancel_order(&mut self, params: Value) -> ResponseData {
        self.request("POST".to_string(),
                     "/api/v2".to_string(),
                     "/mix/order/cancel-order".to_string(),
                     true,
                     params.to_string(),
        ).await
    }

    // 获取订单详情
    pub async fn get_order(&mut self, params: Value) -> ResponseData {
        self.request("GET".to_string(),
                     "/api/v2".to_string(),
                     "/mix/order/detail".to_string(),
                     true,
                     params.to_string(),
        ).await
    }

    // 获取当前未成交订单
    pub async fn get_pending_orders(&mut self) -> ResponseData {
        let params = serde_json::json!({
            "productType": "USDT-FUTURES"
        });

        self.request("GET".to_string(),
                     "/api/v2".to_string(),
                     "/mix/order/orders-pending".to_string(),
                     true,
                     params.to_string(),
        ).await
    }

    // 调整杠杆
    pub async fn set_leverage(&mut self, params: Value) -> ResponseData {
        self.request("POST".to_string(),
                     "/api/v2".to_string(),
                     "/mix/account/set-leverage".to_string(),
                     true,
                     params.to_string(),
        ).await
    }

    // 调整持仓模式（单向、双向）
    pub async fn set_position_mode(&mut self, params: Value) -> ResponseData {
        self.request("POST".to_string(),
                     "/api/v2".to_string(),
                     "/mix/account/set-position-mode".to_string(),
                     true,
                     params.to_string(),
        ).await
    }

    // 发送请求
    pub async fn request(&mut self,
                         method: String,
                         prefix_url: String,
                         request_url: String,
                         is_login: bool,
                         params: String) -> ResponseData
    {
        // trace!("login_param:{:?}", self.login_param);
        //解析账号信息
        let mut access_key = "".to_string();
        let mut secret_key = "".to_string();
        let mut passphrase = "".to_string();
        if self.login_param.contains_key("access_key") {
            access_key = self.login_param.get("access_key").unwrap().to_string();
        }
        if self.login_param.contains_key("secret_key") {
            secret_key = self.login_param.get("secret_key").unwrap().to_string();
        }
        if self.login_param.contains_key("pass_key") {
            passphrase = self.login_param.get("pass_key").unwrap().to_string();
        }
        let mut is_login_param = true;
        if access_key == "" || secret_key == "" || passphrase == "" {
            is_login_param = false
        }

        //请求头配置-如果需要登陆则存在额外配置
        let mut body = "".to_string();
        let timestamp = chrono::Utc::now().timestamp_millis().to_string();
        let mut headers = HeaderMap::new();
        headers.insert("Content-Type", "application/json".parse().unwrap());
        headers.insert("locale", "en-US".parse().unwrap());
        if method == "POST" {
            body = params.clone();
        }

        //是否需要登陆-- 组装sing
        if is_login {
            if !is_login_param {
                let e = ResponseData::error(self.label.clone(), "登录参数错误！".to_string());
                return e;
            } else {
                //需要登陆-且登陆参数齐全
                // trace!("param:{}", params);
                // trace!("body:{}", body);
                //组装sing
                let sing = Self::sign(secret_key.clone(),
                                      method.clone(),
                                      prefix_url.clone(),
                                      request_url.clone(),
                                      params.clone(),
                                      body.clone(),
                                      timestamp.clone(),
                );
                //组装header
                headers.extend(Self::headers(sing, timestamp, passphrase, access_key));
            }
        }


        // trace!("headers:{:?}", headers);
        let base_url = format!("{}{}", prefix_url.clone(), request_url.clone());
        let start_time = chrono::Utc::now().timestamp_millis();
        let get_response = self.http_tool(
            format!("{}{}", prefix_url.clone(), request_url.clone()),
            method.to_string(),
            params.clone(),
            headers,
        ).await;
        let time_array = chrono::Utc::now().timestamp_millis() - start_time;
        self.delays.push(time_array);
        self.get_delay_info();
        let res_data = Self::res_data_analysis(get_response, base_url, params);
        res_data
    }

    pub fn res_data_analysis(result: Result<ResponseData, reqwest::Error>, base_url: String, params: String) -> ResponseData {
        match result {
            Ok(res_data) => {
                if res_data.code != 200 {
                    let json_value = res_data.data;
                    let error = ResponseData::new("".to_string(),
                                                  res_data.code,
                                                  format!("请求地址:{}, 请求参数:{}, 响应结果:{}", base_url, params, res_data.message),
                                                  json_value);
                    error
                } else {
                    let json_value = res_data.data;


                    let code = json_value["code"].as_str().unwrap();
                    if code == "00000" {
                        let data = serde_json::to_string(&json_value["data"]).unwrap();
                        let success = ResponseData::new("".to_string(), 200, "success".to_string(), data.parse().unwrap());
                        success
                    } else {
                        let code_num = i16::from_str(json_value["code"].as_str().unwrap()).unwrap();
                        let error = ResponseData::new("".to_string(), code_num,
                                                      format!("请求地址:{}, 请求参数:{}, 响应结果:{}", base_url, params, json_value.as_str().unwrap()),
                                                      json_value);
                        error
                    }
                }
            }
            Err(err) => {
                let error = ResponseData::error("".to_string(), format!("json 解析失败:{}", err));
                error
            }
        }
    }

    fn get_delay_info(&mut self) {
        let last_100 = if self.delays.len() > 100 {
            self.delays[self.delays.len() - 100..].to_vec()
        } else {
            self.delays.clone()
        };

        let max_value = last_100.iter().max().unwrap();
        if max_value.clone().to_owned() > self.max_delay {
            self.max_delay = max_value.clone().to_owned();
        }

        let sum: i64 = last_100.iter().sum();
        let sum_v = Decimal::from_i64(sum).unwrap();
        let len_v = Decimal::from_u64(last_100.len() as u64).unwrap();
        self.avg_delay = (sum_v / len_v).round_dp(1);
        self.delays = last_100.clone().into_iter().collect();
    }

    // 封装请求头
    pub fn headers(sign: String, timestamp: String, passphrase: String, access_key: String) -> HeaderMap {
        let mut headers = HeaderMap::new();
        headers.insert("ACCESS-KEY", access_key.parse().unwrap());
        headers.insert("ACCESS-SIGN", sign.parse().unwrap());
        headers.insert("ACCESS-TIMESTAMP", timestamp.parse().unwrap());
        headers.insert("ACCESS-PASSPHRASE", passphrase.parse().unwrap());
        headers
    }


    async fn http_tool(&mut 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: String = if RestTool::parse_params_to_str(params.clone()) == "" {
            url.clone()
        } else {
            format!("{}?{}", url.clone(), RestTool::parse_params_to_str(params.clone()))
        };
        // trace!("url:{}", url);
        // trace!("addrs_url:{}", addrs_url);
        // let params_json: serde_json::Value = serde_json::from_str(&params).unwrap();
        // 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(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(self.label.clone(), 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(self.label.clone(), 200, "success".to_string(), body.parse().unwrap());
        } else {
            let body = response.text().await?;
            res_data = ResponseData::error(self.label.clone(), body.to_string())
        }

        Ok(res_data)
    }

    // 对请求进行签名处理
    pub fn sign(secret_key: String,
            method: String, prefix_url: String, request_url: String,
            params: String, body: String, timestamp: String) -> String {
        let url_param_str = RestTool::parse_params_to_str(params);
        let base_url = if method == "GET" && url_param_str.len() > 0 {
            format!("{}{}?{}", prefix_url, request_url, url_param_str)
        } else {
            format!("{}{}", prefix_url, request_url)
        };

        // 时间戳 + 请求类型+ 请求参数字符串
        let message = format!("{}{}{}{}", timestamp, method, base_url, body);
        // trace!("message:{}",message);

        // 做签名
        let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
        let result = hmac::sign(&hmac_key, &message.as_bytes());
        let sign = base64::encode(result);
        sign
    }
}