子账户相关

exchanges/src/gate_swap_rest.rs

@@ -87,7 +87,7 @@ impl GateSwapRest {
         ).await;
         data
     }
-    //查询合约账户
+    // 查询合约账户
     pub async fn get_account(&mut self, settle: String) -> ResponseData {
         let params = serde_json::json!({
          });
@@ -99,7 +99,35 @@ impl GateSwapRest {
         ).await;
         data
     }
-    //用户仓位列表
+
+    // 查询子账户
+    pub async fn sub_account(&mut self) -> ResponseData {
+        let params = serde_json::json!({
+         });
+        let data = self.request("GET".to_string(),
+                                "/api/v4".to_string(),
+                                "/sub_accounts".to_string(),
+                                true,
+                                params.to_string(),
+        ).await;
+        data
+    }
+
+    // 创建新的子账户密钥对
+    pub async fn create_keys(&mut self, user_id: i64) -> ResponseData {
+        let params = serde_json::json!({
+            "name": "futures"
+        });
+        let data = self.request("GET".to_string(),
+                                "/api/v4".to_string(),
+                                format!("/sub_accounts/{}/keys", user_id),
+                                true,
+                                params.to_string(),
+        ).await;
+        data
+    }
+
+    // 用户仓位列表
     pub async fn get_user_position(&mut self, settle: String) -> ResponseData {
         let params = serde_json::json!({
          });

exchanges/tests/gate_swap_test.rs

@@ -1,98 +1,18 @@
 use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
 
-use futures_util::StreamExt;
-use tokio::sync::Mutex;
-use tracing::trace;
+use serde_json::json;
+use tracing::{info};
 
 use exchanges::gate_swap_rest::GateSwapRest;
-use exchanges::gate_swap_ws::{GateSwapLogin, GateSwapSubscribeType, GateSwapWs, GateSwapWsType};
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn ws_custom_subscribe() {
-    global::log_utils::init_log_with_trace();
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-    let param = GateSwapLogin {
-        api_key: ACCESS_KEY.to_string(),
-        secret: SECRET_KEY.to_string(),
-    };
-
-    let mut ws = get_ws(Option::from(param));
-    ws.set_symbols(vec!["BTC_USDT".to_string()]);
-    ws.set_subscribe(vec![
-        // GateSwapSubscribeType::PuFuturesOrderBook,
-        GateSwapSubscribeType::PuFuturesCandlesticks,
-        GateSwapSubscribeType::PuFuturesTrades,
-
-        // GateSwapSubscribeType::PrFuturesBalances("".to_string()),
-        // GateSwapSubscribeType::PrFuturesOrders("".to_string()),
-        // GateSwapSubscribeType::PrFuturesPositions("".to_string()),
-    ]);
-
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
 
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
+const ACCESS_KEY: &str = "92847413a17bf5b786c519b1640f359e";
+const SECRET_KEY: &str = "b4ebcddbd8df5985940cacf7290a8656f2a9c6554f288cd7b7ebcb5e6f7e7026";
 
 
 //rest-设置持仓模式
 #[tokio::test]
 async fn rest_cancel_order_all_test() {
-    global::log_utils::init_log_with_trace();
+    let _guard = global::log_utils::init_log_with_trace();
 
     let mut ret = get_rest();
     let req_data = ret.cancel_order_all().await;
@@ -102,7 +22,7 @@ async fn rest_cancel_order_all_test() {
 //rest-下一个自动单
 #[tokio::test]
 async fn price_order_test() {
-    global::log_utils::init_log_with_info();
+    let _guard = global::log_utils::init_log_with_info();
 
     let mut rest = get_rest();
     let mut params = json!({});
@@ -133,18 +53,18 @@ async fn price_order_test() {
     });
 
     let response_data = rest.place_price_order("usdt".to_string(), params).await;
-    if response_data.code == "200" {
-        let response_obj: serde_json::Value = serde_json::from_str(response_data.data.as_str()).unwrap();
-
-        info!("resp={:?}", response_obj.as_object().unwrap());
+    if response_data.code == 200 {
+        // let response_obj: serde_json::Value = serde_json::from_str(response_data.data.as_str()).unwrap();
+        //
+        // info!("resp={:?}", response_obj.as_object().unwrap());
     } else {
-        error!(?response_data);
+        // error!(?response_data);
     }
 }
 
 #[tokio::test]
 async fn price_order_cancel_test() {
-    global::log_utils::init_log_with_info();
+    let _guard = global::log_utils::init_log_with_info();
 
     let mut rest = get_rest();
 
@@ -156,20 +76,54 @@ async fn price_order_cancel_test() {
 //rest-查询合约账户变更历史
 #[tokio::test]
 async fn rest_account_book_test() {
-    global::log_utils::init_log_with_trace();
+    let _guard = global::log_utils::init_log_with_trace();
 
     let mut ret = get_rest();
     let req_data = ret.account_book("usdt".to_string()).await;
     println!("okx--查询合约账户变更历史--{:?}", req_data);
 }
 
-fn get_ws(btree_map: Option<GateSwapLogin>) -> GateSwapWs {
-    let binance_ws = GateSwapWs::new(false,
-                                     btree_map,
-                                     GateSwapWsType::PublicAndPrivate("usdt".to_string()));
-    binance_ws
+//rest-查询子账户列表
+#[tokio::test]
+async fn rest_sub_accounnt() {
+    let _guard = global::log_utils::init_log_with_info();
+
+    // let mut ret = get_rest();
+    // let req_data = ret.sub_account().await;
+
+    let value = json!([
+        {
+            "remark": "account1",
+            "login_name": "sub_account_for_trades",
+            "user_id": 10001,
+            "state": 1,
+            "create_time": 168888888
+        },
+        {
+            "remark": "account2",
+            "login_name": "sub_account_for_trades",
+            "user_id": 10002,
+            "state": 1,
+            "create_time": 168888888
+        }
+    ]);
+
+    for account in value.as_array().unwrap() {
+        let remark = account.get("remark").unwrap().as_str().unwrap();
+        let login_name = account.get("login_name").unwrap().as_str().unwrap();
+        let user_id = account.get("user_id").unwrap().as_i64().unwrap();
+
+        info!("{}, {}, {}", remark, login_name, user_id)
+    }
 }
 
+// fn get_ws(btree_map: Option<GateSwapLogin>) -> GateSwapWs {
+//     let binance_ws = GateSwapWs::new(false,
+//                                      btree_map,
+//                                      GateSwapWsType::PublicAndPrivate("usdt".to_string()));
+//     binance_ws
+// }
+
 
 fn get_rest() -> GateSwapRest {
     let mut btree_map: BTreeMap<String, String> = BTreeMap::new();

global/src/log_utils.rs

@@ -42,16 +42,16 @@ use tracing_appender_timezone::rolling::{RollingFileAppender, Rotation};
 //     }
 // }
 
-pub fn init_log_with_debug() {
-    let _ = final_init(tracing::Level::DEBUG.as_str(), 0);
+pub fn init_log_with_debug() -> WorkerGuard {
+    final_init(tracing::Level::DEBUG.as_str(), 0)
 }
 
-pub fn init_log_with_trace() {
-    let _ = final_init(tracing::Level::TRACE.as_str(), 0);
+pub fn init_log_with_trace() -> WorkerGuard {
+    final_init(tracing::Level::TRACE.as_str(), 0)
 }
 
-pub fn init_log_with_info() {
-    let _ = final_init(tracing::Level::INFO.as_str(), 0);
+pub fn init_log_with_info() -> WorkerGuard {
+    final_init(tracing::Level::INFO.as_str(), 0)
 }
 
 pub fn final_init(level: &str, port: u32) -> WorkerGuard {

phemex_swap_rest.rs

@@ -1,467 +0,0 @@
-use std::collections::BTreeMap;
-
-use chrono::Utc;
-use reqwest::{Client, Proxy};
-use reqwest::header::HeaderMap;
-use ring::hmac;
-use rust_decimal::Decimal;
-use rust_decimal::prelude::FromPrimitive;
-use rust_decimal_macros::dec;
-use serde_json::{json, Value};
-use tracing::{error, info, trace};
-
-use crate::http_tool::RestTool;
-use crate::proxy;
-use crate::response_base::ResponseData;
-
-#[derive(Clone, Debug)]
-pub struct PhemexSwapRest {
-    pub tag: String,
-    base_url: String,
-    /*******参数*/
-    //是否需要登录
-    //登录所需参数
-    login_param: BTreeMap<String, String>,
-    delays: Vec<i64>,
-    max_delay: i64,
-    avg_delay: Decimal,
-
-}
-
-impl PhemexSwapRest {
-    /*******************************************************************************************************/
-    /*****************************************获取一个对象****************************************************/
-    /*******************************************************************************************************/
-
-    pub fn new(is_colo: bool, login_param: BTreeMap<String, String>) -> PhemexSwapRest
-    {
-        return PhemexSwapRest::new_with_tag("default-PhemexSwapRest".to_string(), is_colo, login_param);
-    }
-    pub fn new_with_tag(tag: String, is_colo: bool, login_param: BTreeMap<String, String>) -> PhemexSwapRest {
-        let base_url = if is_colo {
-            let z = "https://api.phemex.com".to_string();
-            info!("开启高速(未配置，走普通：{})通道",z);
-            z
-        } else {
-            let z = "https://api.phemex.com".to_string();
-            info!("走普通通道：{}",z);
-            z
-        };
-
-
-        /*****返回结构体*******/
-        PhemexSwapRest {
-            tag,
-            base_url,
-            login_param,
-            delays: vec![],
-            max_delay: 0,
-            avg_delay: dec!(0.0),
-        }
-    }
-
-    /*******************************************************************************************************/
-    /*****************************************rest请求函数********************************************************/
-    /*******************************************************************************************************/
-    //服务器时间
-    pub async fn get_server(&mut self) -> ResponseData {
-        let params = json!({});
-        let data = self.request("GET".to_string(),
-                                "".to_string(),
-                                "/public/time".to_string(),
-                                false,
-                                params,
-        ).await;
-        data
-    }
-
-
-    //查詢合約基礎信息
-    pub async fn get_market(&mut self, params: Value) -> ResponseData {
-        let data = self.request("GET".to_string(),
-                                "".to_string(),
-                                "/public/products".to_string(),
-                                false,
-                                params,
-        ).await;
-        data
-    }
-
-    //查詢ticker(Query 24 ticker)
-    pub async fn get_ticker(&mut self, params: Value) -> ResponseData {
-        let data = self.request("GET".to_string(),
-                                "".to_string(),
-                                "/md/v3/ticker/24hr".to_string(),
-                                false,
-                                params,
-        ).await;
-        data
-    }
-
-
-    //持仓(查询交易账户和仓位)
-    pub async fn get_account_and_positions(&mut self, params: Value) -> ResponseData {
-        let data = self.request("GET".to_string(),
-                                "".to_string(),
-                                "/g-accounts/accountPositions".to_string(),
-                                true,
-                                params,
-        ).await;
-        data
-    }
-
-    //仓位设置(Switch Position Mode Synchronously)
-    pub async fn set_target_pos_mode(&mut self, params: Value) -> ResponseData {
-        let data = self.request("PUT".to_string(),
-                                "".to_string(),
-                                "/g-positions/switch-pos-mode-sync".to_string(),
-                                true,
-                                params,
-        ).await;
-        data
-    }
-
-    //设置杠杆（Set Leverage 设置杠杆）
-    pub async fn set_leverage(&mut self, params: Value) -> ResponseData {
-        let data = self.request("PUT".to_string(),
-                                "".to_string(),
-                                "/g-positions/leverage".to_string(),
-                                true,
-                                params,
-        ).await;
-        data
-    }
-
-    //下单
-    pub async fn orders(&mut self, params: Value) -> ResponseData {
-        let data = self.request("PUT".to_string(),
-                                "".to_string(),
-                                "/g-orders/create".to_string(),
-                                true,
-                                params,
-        ).await;
-        data
-    }
-
-
-    //撤单
-    pub async fn cancel_order(&mut self, params: Value) -> ResponseData {
-        let data = self.request("DELETE".to_string(),
-                                "".to_string(),
-                                "/g-orders/cancel".to_string(),
-                                true,
-                                params,
-        ).await;
-        data
-    }
-
-    //撤销所有
-    pub async fn cancel_order_all(&mut self, params: Value) -> ResponseData {
-        let data = self.request("DELETE".to_string(),
-                                "".to_string(),
-                                "/g-orders/all".to_string(),
-                                true,
-                                params,
-        ).await;
-        data
-    }
-
-    //订单列表
-    pub async fn get_orders(&mut self, params: Value) -> ResponseData {
-        let data = self.request("GET".to_string(),
-                                "".to_string(),
-                                "/api-data/g-futures/orders".to_string(),
-                                true,
-                                params,
-        ).await;
-        data
-    }
-
-    //根据id查询订单
-    pub async fn get_orders_by_id(&mut self, params: Value) -> ResponseData {
-        let data = self.request("GET".to_string(),
-                                "".to_string(),
-                                "/api-data/g-futures/orders/by-order-id".to_string(),
-                                true,
-                                params,
-        ).await;
-        data
-    }
-
-    /*******************************************************************************************************/
-    /*****************************************工具函数********************************************************/
-    /*******************************************************************************************************/
-    pub fn get_delays(&self) -> Vec<i64> {
-        self.delays.clone()
-    }
-    pub fn get_avg_delay(&self) -> Decimal {
-        self.avg_delay.clone()
-    }
-    pub fn get_max_delay(&self) -> i64 {
-        self.max_delay.clone()
-    }
-    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 async fn request(&mut self,
-                         method: String,
-                         prefix_url: String,
-                         request_url: String,
-                         is_login: bool,
-                         params_json: Value) -> ResponseData
-    {
-        trace!("login_param:{:?}", self.login_param);
-        //解析账号信息
-        let mut access_key = "".to_string();
-        let mut secret_key = "".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();
-        }
-        let mut is_login_param = true;
-        if access_key == "" || secret_key == "" {
-            is_login_param = false
-        }
-
-        //每个接口都有的参数
-        let timestamp = (Utc::now().timestamp_millis() + (60 * 1000)) / 1000;
-
-        //请求类型不同，可能请求头body 不同
-        let mut body = "".to_string();
-        let mut params = "".to_string();
-        let mut headers = HeaderMap::new();
-        if method == "POST" {
-            body = params_json.to_string();
-        }
-        if method == "GET" || method == "PUT" || method == "DELETE" {
-            let z = params_json.to_string();
-            params = RestTool::parse_params_to_str(z);
-        }
-
-        //是否需要登录-- 组装sing
-        if is_login {
-            if !is_login_param {
-                let e = ResponseData::error(self.tag.clone(), "登录参数错误！".to_string());
-                return e;
-            } else {
-                //需要登录-且登录参数齐全
-                trace!("Path:{}{}", prefix_url.clone(),request_url.clone());
-                trace!("Query:{}", params);
-                trace!("Body:{}", body);
-                trace!("expire:{}", timestamp.to_string());
-                //组装sing
-                let sing = Self::sign(secret_key.clone(),
-                                      prefix_url.clone(),
-                                      request_url.clone(),
-                                      params.clone(),
-                                      body.clone(),
-                                      timestamp.to_string(),
-                );
-                trace!("Signature:{}", sing);
-                //组装header
-                headers.extend(Self::headers(sing, timestamp.to_string(), access_key));
-            }
-        }
-
-
-        let start_time = chrono::Utc::now().timestamp_millis();
-        let response = self.http_tool(
-            format!("{}{}", prefix_url.clone(), request_url.clone()),
-            method.to_string(),
-            params.clone(),
-            body.clone(),
-            headers,
-            is_login,
-        ).await;
-
-        let time_array = chrono::Utc::now().timestamp_millis() - start_time;
-        self.delays.push(time_array);
-        self.get_delay_info();
-
-        response
-    }
-
-    pub fn headers(sign: String, timestamp: String, access_key: String) -> HeaderMap {
-        let mut headers = HeaderMap::new();
-        headers.insert("x-phemex-access-token", access_key.parse().unwrap());// 这是 Phemex 网站的 API-KEY（id 字段）
-        headers.insert("x-phemex-request-expiry", timestamp.parse().unwrap());// 描述请求过期的 Unix EPoch 秒数，通常应为 (Now() + 1 分钟)
-        headers.insert("x-phemex-request-signature", sign.parse().unwrap());// 这是 http 请求的 HMAC SHA256 签名。Secret 是 API Secret，其公式为：HMacSha256(URL Path + QueryString + Expiry + body)
-        // let tracing = format!("4l_{:?}", Utc::now().timestamp_millis().to_string());
-        // headers.insert("x-phemex-request-tracing", tracing.parse().unwrap());
-        headers
-    }
-    pub fn sign(secret_key: String,
-                prefix_url: String, request_url: String,
-                url_param_str: String, body: String, timestamp: String) -> String
-    {
-        /*签名生成*/
-        let base_url = format!("{}{}", prefix_url, request_url);
-        // HMacSha256(URL Path + QueryString + Expiry + body)
-
-        // 时间戳 + 请求类型+ 请求参数字符串
-        let message = format!("{}{}{}{}", base_url, url_param_str, timestamp, body);
-        trace!("message:{}",message);
-
-        // 做签名
-        let hmac_key = ring::hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
-        let sign = hex::encode(hmac::sign(&hmac_key, message.as_bytes()).as_ref());
-        sign
-    }
-
-    // async fn http_tool(&mut self, request_path: String, request_type: String, params: String, headers: HeaderMap) -> Result<ResponseData, reqwest::Error> {
-    async fn http_tool(&mut self, request_path: String,
-                       request_type: String,
-                       params: String,
-                       body: String,
-                       headers: HeaderMap,
-                       is_login: bool) -> ResponseData {
-        /****请求接口与 地址*/
-        let url = format!("{}{}", self.base_url.to_string(), request_path);
-        let request_type = request_type.clone().to_uppercase();
-        let addrs_url: String = if params == "" {
-            url.clone()
-        } else {
-            format!("{}?{}", url.clone(), params)
-        };
-
-        trace!("url-----:{}",url.clone());
-        trace!("addrs_url-----:{}",addrs_url.clone());
-        trace!("params-----:{}",params.clone());
-        trace!("body-----:{}",body.clone());
-        trace!("headers-----:{:?}",headers.clone());
-        trace!("request_type-----:{:?}",request_type.clone());
-
-
-        let client = if is_login {
-            let params = proxy::ParsingDetail::http_enable_proxy(Some("phemex"));
-            let client_re;
-            if params {
-                let proxy_address = "socks5://127.0.0.1:17890"; // 替换为你的 SOCKS5 代理地址
-                let proxy = Proxy::all(proxy_address).unwrap();
-                client_re = Client::builder().proxy(proxy).build().unwrap();
-            } else {
-                client_re =  Client::new()
-            }
-            client_re
-        } else {
-            proxy::ParsingDetail::http_enable_proxy(None);
-            Client::new()
-        };
-        let request_builder = match request_type.as_str() {
-            "GET" => client.get(addrs_url.clone()).headers(headers),
-            "POST" => client.post(url.clone()).body(body).headers(headers),
-            "DELETE" => client.delete(addrs_url.clone()).headers(headers),
-            "PUT" => client.put(addrs_url.clone()).headers(headers),
-            _ => {
-                panic!("{}", format!("错误的请求类型:{}", request_type.clone()))
-            }
-        };
-
-
-        // 读取响应的内容
-        let response = request_builder.send().await.unwrap();
-        let is_success = response.status().is_success(); // 先检查状态码
-        let text = response.text().await.unwrap();
-        // trace!("text:{:?}",text);
-        return if is_success {
-            self.on_success_data(&text)
-        } else {
-            self.on_error_data(&text, &addrs_url, &params)
-        };
-    }
-    pub fn on_success_data(&mut self, text: &String) -> ResponseData {
-        let json_value = serde_json::from_str::<Value>(&text).unwrap();
-        // return  ResponseData::new(self.tag.clone(), 200, "success".to_string(), json_value);
-
-        let id = json_value["id"].as_i64();
-        match id {
-            None => {}
-            Some(v) => {
-                match v {
-                    0 => {
-                        let result = json_value.get("result").unwrap();
-                        return ResponseData::new(self.tag.clone(), 200, "success".to_string(), result.clone());
-                    }
-                    _ => {}
-                }
-            }
-        }
-
-        let code = json_value["code"].as_i64();
-        match code {
-            None => {}
-            Some(v) => {
-                match v {
-                    0 => {
-                        //判断是否有code ，没有表示特殊接口，直接返回
-                        if json_value.get("data").is_some() {
-                            let data = json_value.get("data").unwrap();
-                            return ResponseData::new(self.tag.clone(), 200, "success".to_string(), data.clone());
-                        } else {
-                            return ResponseData::new(self.tag.clone(), 200, "success".to_string(), json_value);
-                        }
-                    }
-                    _ => {
-                        if json_value.get("msg").is_some() {
-                            return ResponseData::new(self.tag.clone(), 400, format!("{:?}", json_value["msg"].as_str()), json_value);
-                        } else {
-                            return ResponseData::new(self.tag.clone(), 400, "error".to_string(), json_value);
-                        }
-                    }
-                }
-            }
-        }
-
-
-        return ResponseData::new(self.tag.clone(), 400, "error".to_string(), json_value);
-    }
-
-    pub fn on_error_data(&mut self, text: &String, _base_url: &String, _params: &String) -> ResponseData {
-        let json_value = serde_json::from_str::<Value>(&text);
-
-
-        match json_value {
-            Ok(data) => {
-                let code = data["code"].as_i64();
-                match code {
-                    None => {}
-                    Some(v) => {
-                        match v {
-                            _ => {
-                                if data.get("msg").is_some() {
-                                    return ResponseData::new(self.tag.clone(), 400, format!("{:?}", data["msg"].as_str().unwrap()), data);
-                                } else {
-                                    return ResponseData::new(self.tag.clone(), 400, "error".to_string(), data);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            Err(e) => {
-                error!("解析错误：{:?}", e);
-                return ResponseData::error("".to_string(),
-                                           format!("json 解析失败:{}，相关参数:{}", e, text));
-            }
-        }
-        return ResponseData::error("".to_string(), format!("请求失败：{:?}", text));
-    }
-}