3.2.0发布，网络状态码升级为i16

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "as-rust"
-version = "3.1.4"
+version = "3.2.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

exchanges/src/binance_swap_rest.rs

@@ -1,4 +1,5 @@
 use std::collections::BTreeMap;
+use std::str::FromStr;
 use reqwest::header::HeaderMap;
 use hex;
 use reqwest::Client;
@@ -432,7 +433,7 @@ impl BinanceSwapRest {
     pub fn on_success_data(&mut self, text: String) -> ResponseData {
         let data = serde_json::from_str(text.as_str()).unwrap();
 
-        ResponseData::new(self.label.clone(), "200".to_string(), "success".to_string(), data)
+        ResponseData::new(self.label.clone(), 200, "success".to_string(), data)
     }
 
     pub fn on_error_data(&mut self, text: String, base_url: String, params: String) -> ResponseData {
@@ -443,7 +444,7 @@ impl BinanceSwapRest {
                 let message = data["msg"].as_str().unwrap();
 
                 let mut error = ResponseData::error(self.label.clone(), message.to_string());
-                error.code = data["code"].to_string();
+                error.code = i16::from_str(data["code"].as_str().unwrap()).unwrap();
                 error.message = format!("请求地址：{}, 请求参数：{}", base_url, params);
                 error
             }

exchanges/src/binance_swap_ws.rs

@@ -1,3 +1,4 @@
+use std::str::FromStr;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 use std::time::Duration;
@@ -212,30 +213,30 @@ impl BinanceSwapWs {
     }
     //数据解析-ping
     pub fn message_ping(_pi: Vec<u8>) -> Option<ResponseData> {
-        return Option::from(ResponseData::new("".to_string(), "-300".to_string(), "success".to_string(), Value::String("pong".to_string())));
+        return Option::from(ResponseData::new("".to_string(), -300, "success".to_string(), Value::String("pong".to_string())));
     }
     //数据解析-pong
     pub fn message_pong(_po: Vec<u8>) -> Option<ResponseData> {
-        return Option::from(ResponseData::new("".to_string(), "-301".to_string(), "success".to_string(), Value::Null));
+        return Option::from(ResponseData::new("".to_string(), -301, "success".to_string(), Value::Null));
     }
     //数据解析
     pub fn ok_text(text: String) -> ResponseData {
         // trace!("原始数据");
         // trace!(?text);
-        let mut res_data = ResponseData::new("".to_string(), "200".to_string(), "success".to_string(), Value::Null);
+        let mut res_data = ResponseData::new("".to_string(), 200, "success".to_string(), Value::Null);
         let json_value: Value = serde_json::from_str(&text).unwrap();
 
         if json_value.get("result").is_some() && json_value.get("id").is_some() &&
             json_value.get("id").unwrap() == 1
         {
-            res_data.code = "-201".to_string();
+            res_data.code = -201;
             res_data.message = "订阅成功".to_string();
         } else if json_value.get("error").is_some() {//订阅返回
-            res_data.code = json_value["error"]["code"].to_string();
+            res_data.code = i16::from_str(json_value["error"]["code"].as_str().unwrap()).unwrap();
             res_data.message = json_value["error"]["msg"].to_string();
         } else if json_value.get("stream").is_some() {//订阅返回
             res_data.data = json_value["data"].clone();
-            res_data.code = "200".to_string();
+            res_data.code = 200;
 
             let channel = json_value["stream"].as_str().unwrap();
             if channel.contains("@aggTrade") {
@@ -245,11 +246,11 @@ impl BinanceSwapWs {
             } else if channel.contains("@bookTicker") {
                 res_data.channel = "bookTicker".to_string();
             } else {
-                res_data.code = "".to_string();
+                res_data.code = -1;
                 res_data.channel = "未知的频道".to_string();
             }
         } else {
-            res_data.code = "".to_string();
+            res_data.code = -1;
             res_data.channel = "未知的频道2".to_string();
         }
         res_data

exchanges/src/bitget_swap_rest.rs

@@ -1,4 +1,5 @@
 use std::collections::BTreeMap;
+use std::str::FromStr;
 use reqwest::Client;
 use reqwest::header::HeaderMap;
 use rust_decimal::Decimal;
@@ -269,25 +270,25 @@ impl BitgetSwapRest {
     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" {
+                if res_data.code != 200 {
                     let json_value = res_data.data;
-                    let code = res_data.code;
                     let error = ResponseData::new("".to_string(),
-                                                  format!("{}", code),
+                                                  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".to_string(), "success".to_string(), data.parse().unwrap());
+                        let success = ResponseData::new("".to_string(), 200, "success".to_string(), data.parse().unwrap());
                         success
                     } else {
-                        let error = ResponseData::new("".to_string(),
-                                                      format!("{}", code),
+                        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
@@ -360,7 +361,7 @@ impl BitgetSwapRest {
             // 读取响应的内容
             let body = response.text().await?;
             // trace!("ok-----{}", body);
-            res_data = ResponseData::new(self.label.clone(), "200".to_string(), "success".to_string(), body.parse().unwrap());
+            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())

exchanges/src/bitget_swap_ws.rs

@@ -282,18 +282,18 @@ impl BitgetSwapWs {
     }
     // 数据解析-ping
     pub fn message_ping(_pi: Vec<u8>) -> Option<ResponseData> {
-        return Option::from(ResponseData::new("".to_string(), "-300".to_string(), "success".to_string(), Value::Null));
+        return Option::from(ResponseData::new("".to_string(), -300, "success".to_string(), Value::Null));
     }
     // 数据解析-pong
     pub fn message_pong(_po: Vec<u8>) -> Option<ResponseData> {
-        return Option::from(ResponseData::new("".to_string(), "-301".to_string(), "success".to_string(), Value::Null));
+        return Option::from(ResponseData::new("".to_string(), -301, "success".to_string(), Value::Null));
     }
     //数据解析
     pub fn ok_text(text: String) -> ResponseData {
-        let mut res_data = ResponseData::new("".to_string(), "200".to_string(), text.clone(), Value::Null);
+        let mut res_data = ResponseData::new("".to_string(), 200, text.clone(), Value::Null);
         match text.as_str() {
             "pong" => {
-                res_data.code = "-301".to_string();
+                res_data.code = -301;
                 res_data.channel = "pong".to_string();
                 res_data.message = "success".to_string();
             },
@@ -307,19 +307,19 @@ impl BitgetSwapWs {
                         res_data.message = format!("登陆失败:({},{})", json_value.get("code").as_ref().unwrap(), json_value.get("msg").as_ref().unwrap());
                     }
                     res_data.channel = "login".to_string();
-                    res_data.code = "-200".to_string();
+                    res_data.code = -200;
                     res_data.data = json_value;
                 } else if json_value.get("event").is_some() && json_value["event"].as_str() == Some("subscribe") {
-                    res_data.code = "-201".to_string();
+                    res_data.code = -201;
                     res_data.data = json_value.clone();
                     res_data.channel = format!("{}", json_value["arg"]["channel"].as_str().unwrap());
                     res_data.message = "success".to_string();
                 } else if json_value.get("action").is_some() {
                     res_data.data = json_value["data"].clone();
                     if res_data.data == "[]" {
-                        res_data.code = "".to_string();
+                        res_data.code = -1;
                     } else {
-                        res_data.code = "200".to_string();
+                        res_data.code = 200;
                     }
                     res_data.message = "success".to_string();
                     res_data.channel = format!("{}", json_value["arg"]["channel"].as_str().unwrap());

exchanges/src/bybit_swap_rest.rs

@@ -454,7 +454,7 @@ impl BybitSwapRest {
 
         if code == 0 {
             let data = serde_json::to_string(&json_value["result"]).unwrap();
-            let mut success = ResponseData::new("".to_string(), "200".to_string(), "success".to_string(), data.parse().unwrap());
+            let mut success = ResponseData::new("".to_string(), 200, "success".to_string(), data.parse().unwrap());
             success.time = json_value["time"].as_i64().unwrap();
             success
         } else {
@@ -467,7 +467,7 @@ impl BybitSwapRest {
             };
 
             let error = ResponseData::new("".to_string(),
-                                          format!("{}", code),
+                                          code as i16,
                                           format!("请求地址：{}, 请求参数：{}, 消息原文：{}。", base_url, params, msg),
                                           Value::Null);
             error

exchanges/src/bybit_swap_ws.rs

@@ -271,17 +271,17 @@ impl BybitSwapWs {
     }
     //数据解析-ping
     pub fn message_ping(_pi: Vec<u8>) -> Option<ResponseData> {
-        return Option::from(ResponseData::new("".to_string(), "-300".to_string(), "success".to_string(), Value::Null));
+        return Option::from(ResponseData::new("".to_string(), -300, "success".to_string(), Value::Null));
     }
     //数据解析-pong
     pub fn message_pong(_po: Vec<u8>) -> Option<ResponseData> {
-        return Option::from(ResponseData::new("".to_string(), "-301".to_string(), "success".to_string(), Value::Null));
+        return Option::from(ResponseData::new("".to_string(), -301, "success".to_string(), Value::Null));
     }
     //数据解析
     pub fn ok_text(text: String) -> ResponseData {
         // trace!("原始数据");
         // trace!(?text);
-        let mut res_data = ResponseData::new("".to_string(), "200".to_string(), "success".to_string(), Value::Null);
+        let mut res_data = ResponseData::new("".to_string(), 200, "success".to_string(), Value::Null);
         let json_value: Value = serde_json::from_str(&text).unwrap();
         if json_value.get("success").is_some() {
             info!("bybit_swap_ws订阅结果：{:?}", json_value);
@@ -296,20 +296,20 @@ impl BybitSwapWs {
             };
 
             if op == "auth" {
-                res_data.code = "-200".to_string();
+                res_data.code = -200;
                 res_data.message = format!("登录{}", success_error);
             } else if op == "subscribe" {
                 res_data.message = format!("订阅{}", success_error);
-                res_data.code = "-201".to_string();
+                res_data.code = -201;
             } else {
-                res_data.code = "".to_string();
+                res_data.code = -1;
                 res_data.channel = "未知订阅".to_string();
             }
         } else if json_value.get("topic").is_some() && json_value.get("data").is_some() {
             let channel = json_value["topic"].to_string();
             res_data.data = json_value["data"].clone();
 
-            res_data.code = "200".to_string();
+            res_data.code = 200;
 
             if channel.contains("orderbook") {
                 res_data.channel = "orderbook".to_string();
@@ -333,12 +333,12 @@ impl BybitSwapWs {
             } else if channel.contains("wallet") {
                 res_data.channel = "wallet".to_string();
             } else {
-                res_data.code = "".to_string();
+                res_data.code = -1;
                 res_data.channel = "未知的频道".to_string();
             }
         } else {
             //推送数据
-            res_data.code = "".to_string();
+            res_data.code = -1;
             res_data.channel = "未知的频道".to_string();
         }
 

exchanges/src/gate_swap_rest.rs

@@ -583,10 +583,7 @@ impl GateSwapRest {
     pub fn on_success_data(&mut self, text: &String) -> ResponseData {
         let data = serde_json::from_str(text.as_str()).unwrap();
 
-        ResponseData::new(self.label.clone(),
-                          "200".to_string(),
-                          "success".to_string(),
-                          data)
+        ResponseData::new(self.label.clone(), 200, "success".to_string(), data)
     }
 
     pub fn on_error_data(&mut self, text: &String, base_url: &String, params: &String) -> ResponseData {

exchanges/src/gate_swap_ws.rs

@@ -1,3 +1,4 @@
+use std::str::FromStr;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 use std::time::Duration;
@@ -323,34 +324,34 @@ impl GateSwapWs {
     }
     //数据解析-ping
     pub fn message_ping(_pi: Vec<u8>) -> Option<ResponseData> {
-        return Option::from(ResponseData::new("".to_string(), "-300".to_string(), "success".to_string(), Value::Null));
+        return Option::from(ResponseData::new("".to_string(), -300, "success".to_string(), Value::Null));
     }
     //数据解析-pong
     pub fn message_pong(_po: Vec<u8>) -> Option<ResponseData> {
-        return Option::from(ResponseData::new("".to_string(), "-301".to_string(), "success".to_string(), Value::Null));
+        return Option::from(ResponseData::new("".to_string(), -301, "success".to_string(), Value::Null));
     }
     //数据解析
     pub fn ok_text(text: String) -> ResponseData
     {
         // trace!("原始数据：{}", text);
-        let mut res_data = ResponseData::new("".to_string(), "200".to_string(), "success".to_string(), Value::Null);
+        let mut res_data = ResponseData::new("".to_string(), 200, "success".to_string(), Value::Null);
         let json_value: Value = serde_json::from_str(&text).unwrap();
 
         if json_value["channel"].as_str() == Option::from("futures.pong") {
-            res_data.code = "-301".to_string();
+            res_data.code = -301;
             res_data.message = "success".to_string();
         } else if json_value.get("error").is_some() {
             let message = json_value["error"]["message"].as_str().unwrap().to_string();
             let mes = message.trim_end_matches('\n');
 
-            res_data.code = json_value["error"]["code"].to_string();
+            res_data.code = i16::from_str(json_value["error"]["code"].as_str().unwrap()).unwrap();
             res_data.message = mes.to_string();
         } else if json_value["result"]["status"].as_str() == Option::from("success") {//订阅返回
-            res_data.code = "-201".to_string();
+            res_data.code = -201;
             res_data.data = json_value;
         } else {
             res_data.channel = format!("{}", json_value["channel"].as_str().unwrap());
-            res_data.code = "200".to_string();
+            res_data.code = 200;
             res_data.data = json_value["result"].clone();
         }
         res_data

exchanges/src/http_tool.rs

@@ -74,7 +74,7 @@ impl RestTool {
     pub fn res_data_analysis(result: Result<ResponseData, reqwest::Error>) -> ResponseData {
         match result {
             Ok(res_data) => {
-                if res_data.code != "0" {
+                if res_data.code != 0 {
                     res_data
                 } else {
                     let json_value= res_data.data;

exchanges/src/kucoin_swap_rest.rs

@@ -573,7 +573,7 @@ impl KucoinSwapRest {
             let body = response.text().await?;
 
             let data = serde_json::from_str(body.as_str()).unwrap();
-            res_data = ResponseData::new(self.label.clone(), "200".to_string(), "success".to_string(), data);
+            res_data = ResponseData::new(self.label.clone(), 200, "success".to_string(), data);
         } else {
             let body = response.text().await?;
             // trace!("error-----{}", body);
@@ -588,7 +588,7 @@ impl KucoinSwapRest {
     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" {
+                if res_data.code != 200 {
                     // res_data
                     let mut error = res_data;
                     error.message = format!("错误：{},url：{},相关参数：{}", error.message, base_url, params);
@@ -611,7 +611,7 @@ impl KucoinSwapRest {
                         error
                     } else {
                         let data = serde_json::to_string(&json_value["data"]).unwrap();
-                        let success = ResponseData::new("".to_string(), "200".to_string(), "success".to_string(), data.parse().unwrap());
+                        let success = ResponseData::new("".to_string(), 200, "success".to_string(), data.parse().unwrap());
                         success
                     }
                 }

exchanges/src/kucoin_swap_ws.rs

@@ -1,4 +1,5 @@
 use std::collections::BTreeMap;
+use std::str::FromStr;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 use std::time::Duration;
@@ -150,7 +151,7 @@ impl KucoinSwapWs {
 
         trace!("kucoin-swap-rest 获取ws连接地址：{:?}",res_data);
 
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let mut ws_url = "".to_string();
             let mut ws_token = "".to_string();
             let mut ws_ping_interval: i64 = 0;
@@ -351,44 +352,44 @@ impl KucoinSwapWs {
     }
     //数据解析-ping
     pub fn message_ping(_pi: Vec<u8>) -> Option<ResponseData> {
-        return Option::from(ResponseData::new("".to_string(), "-300".to_string(), "success".to_string(), Value::Null));
+        return Option::from(ResponseData::new("".to_string(), -300, "success".to_string(), Value::Null));
     }
     //数据解析-pong
     pub fn message_pong(_po: Vec<u8>) -> Option<ResponseData> {
-        return Option::from(ResponseData::new("".to_string(), "-301".to_string(), "success".to_string(), Value::Null));
+        return Option::from(ResponseData::new("".to_string(), -301, "success".to_string(), Value::Null));
     }
     //数据解析
     pub fn ok_text(text: String) -> ResponseData
     {
         // trace!("原始数据:{:?}",text);
-        let mut res_data = ResponseData::new("".to_string(), "200".to_string(), "success".to_string(), Value::Null);
+        let mut res_data = ResponseData::new("".to_string(), 200, "success".to_string(), Value::Null);
         let json_value: serde_json::Value = serde_json::from_str(&text).unwrap();
 
         //订阅 相应
         if json_value["type"].as_str() == Option::from("welcome") {
             //链接成功
-            res_data.code = "-200".to_string();
+            res_data.code = -200;
             res_data.message = "链接成功，主动发起订阅".to_string();
         } else if json_value["type"].as_str() == Option::from("ack") {
-            res_data.code = "-201".to_string();
+            res_data.code = -201;
             res_data.message = "订阅成功".to_string();
         } else if json_value["type"].as_str() == Option::from("error") {
-            res_data.code = format!("{}", json_value["code"]);
+            res_data.code = i16::from_str(json_value["code"].as_str().unwrap()).unwrap();
             res_data.message = format!("{}", json_value["data"].as_str().unwrap());
         } else if json_value.get("topic").is_some() {
             res_data.channel = format!("{}", json_value["subject"].as_str().unwrap());
 
             if json_value["topic"].as_str() == Option::from("/contractAccount/wallet") {
-                res_data.code = "".to_string();
+                res_data.code = -1;
                 if json_value["subject"].as_str() == Option::from("availableBalance.change") {
-                    res_data.code = "200".to_string();
+                    res_data.code = 200;
                     res_data.data = json_value["data"].clone();
                 } else {}
             } else {
                 res_data.data = json_value["data"].clone();
             }
         } else {
-            res_data.code = "".to_string();
+            res_data.code = -1;
             res_data.message = "未知解析".to_string();
         }
         res_data

exchanges/src/response_base.rs

@@ -5,7 +5,7 @@ use tokio::time::Instant;
 #[derive(Debug, Clone)]
 pub struct ResponseData {
     pub label: String,
-    pub code: String,
+    pub code: i16,
     pub message: String,
     pub channel: String,
     pub data: Value,
@@ -16,7 +16,7 @@ pub struct ResponseData {
 }
 
 impl ResponseData {
-    pub fn new(label: String, code: String, message: String, data: Value) -> ResponseData {
+    pub fn new(label: String, code: i16, message: String, data: Value) -> ResponseData {
         ResponseData {
             label,
             code,
@@ -32,7 +32,7 @@ impl ResponseData {
     pub fn error(label: String, message: String) -> ResponseData {
         ResponseData {
             label,
-            code: "-1".to_string(),
+            code: -1,
             message: format!("{}", &message),
             data: Value::Null,
             channel: "".to_string(),

exchanges/src/socket_tool.rs

@@ -85,7 +85,7 @@ impl AbstractWsMode {
 
                     let code = data.code.clone();
 
-                    if code == "200" {
+                    if code == 200 {
                         let mut data_c = data.clone();
                         data_c.ins = Instant::now();
 
@@ -100,8 +100,8 @@ impl AbstractWsMode {
                        -301 -客户端收到服务器心跳pong，需要响应
                        -302 -客户端收到服务器心跳自定义，需要响应自定义
                     */
-                    match code.as_str() {
-                        "-200" => {
+                    match code {
+                        -200 => {
                             //登录成功
                             info!("ws登录成功：{:?}", data);
                             info!("订阅内容：{:?}", subscribe_array.clone());
@@ -110,11 +110,11 @@ impl AbstractWsMode {
                                 write_lock.send(Message::Text(s.parse().unwrap())).await.expect("订阅消息失败");
                             }
                         }
-                        "-201" => {
+                        -201 => {
                             //订阅成功
                             trace!("订阅成功：{:?}", data);
                         }
-                        "-300" => {
+                        -300 => {
                             //服务器发送心跳 ping 给客户端，客户端需要pong回应
                             trace!("服务器响应-ping");
                             if data.data != Value::Null {
@@ -123,7 +123,7 @@ impl AbstractWsMode {
                                 trace!("客户端回应服务器-pong");
                             }
                         }
-                        "-301" => {
+                        -301 => {
                             //服务器发送心跳 pong 给客户端，客户端需要ping回应
                             trace!("服务器响应-pong");
                             if data.data != Value::Null {
@@ -132,7 +132,7 @@ impl AbstractWsMode {
                                 trace!("客户端回应服务器-ping");
                             }
                         }
-                        "-302" => {
+                        -302 => {
                             //客户端收到服务器心跳自定义，需要响应自定义
                             trace!("特定字符心跳，特殊响应：{:?}", data);
                             let mut ws_write = ws_write_inner.lock().await;
@@ -242,31 +242,23 @@ impl AbstractWsMode {
                 //二进制WebSocket消息
                 let message_str = format!("Binary:{:?}", s);
                 trace!("{:?}",message_str);
-                Option::from(ResponseData::new("".to_string(),
-                                               "2".to_string(),
-                                               message_str, Value::Null))
+                Option::from(ResponseData::new("".to_string(), 2, message_str, Value::Null))
             }
             Ok(Message::Close(c)) => {
                 let message_str = format!("关闭指令:{:?}", c);
                 trace!("{:?}",message_str);
-                Option::from(ResponseData::new("".to_string(),
-                                               "0".to_string(),
-                                               message_str, Value::Null))
+                Option::from(ResponseData::new("".to_string(), 0, message_str, Value::Null))
             }
             Ok(Message::Frame(f)) => {
                 //原始帧 正常读取数据不会读取到该 信息类型
                 let message_str = format!("意外读取到原始帧:{:?}", f);
                 trace!("{:?}",message_str);
-                Option::from(ResponseData::new("".to_string(),
-                                               "-2".to_string(),
-                                               message_str, Value::Null))
+                Option::from(ResponseData::new("".to_string(), -2, message_str, Value::Null))
             }
             Err(e) => {
                 let message_str = format!("服务器响应:{:?}", e);
                 trace!("{:?}",message_str);
-                Option::from(ResponseData::new("".to_string(),
-                                               "-1".to_string(),
-                                               message_str, Value::Null))
+                Option::from(ResponseData::new("".to_string(), -1, message_str, Value::Null))
             }
         }
     }

standard/src/binance_swap.rs

@@ -75,7 +75,7 @@ impl Platform for BinanceSwap {
     // 获取服务器时间
     async fn get_server_time(&mut self) -> Result<String, Error> {
         let res_data = self.request.get_server_time().await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let result = res_data_json["serverTime"].to_string();
             Ok(result)
@@ -87,7 +87,7 @@ impl Platform for BinanceSwap {
     async fn get_account(&mut self) -> Result<Account, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_account().await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let balance_info = res_data_json.iter().find(|item| item["asset"].as_str().unwrap().to_string() == symbol_array[1].to_string());
             match balance_info {
@@ -125,7 +125,7 @@ impl Platform for BinanceSwap {
         let symbol_format = utils::format_symbol(self.symbol.clone(), "");
         let ct_val = self.market.ct_val;
         let res_data = self.request.get_position_risk(symbol_format).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let result = res_data_json.iter().map(|item| { format_position_item(item, ct_val) }).collect();
             Ok(result)
@@ -136,7 +136,7 @@ impl Platform for BinanceSwap {
 
     async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
         let res_data = self.request.get_position_risk("".to_string()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let result = res_data_json.iter().map(|item| { format_position_item(item, Decimal::ONE) }).collect();
             Ok(result)
@@ -149,7 +149,7 @@ impl Platform for BinanceSwap {
     async fn get_ticker(&mut self) -> Result<Ticker, Error> {
         let symbol_format = utils::format_symbol(self.symbol.clone(), "");
         let res_data = self.request.get_book_ticker(symbol_format).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json: serde_json::Value = res_data.data;
             let result = Ticker {
                 time: res_data_json["time"].as_i64().unwrap(),
@@ -169,7 +169,7 @@ impl Platform for BinanceSwap {
     async fn get_ticker_symbol(&mut self, symbol: String) -> Result<Ticker, Error> {
         let symbol_format = utils::format_symbol(symbol.clone(), "");
         let res_data = self.request.get_book_ticker(symbol_format).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json: serde_json::Value = res_data.data;
             let result = Ticker {
                 time: res_data_json["time"].as_i64().unwrap(),
@@ -189,7 +189,7 @@ impl Platform for BinanceSwap {
     async fn get_market(&mut self) -> Result<Market, Error> {
         let symbol_format = utils::format_symbol(self.symbol.clone(), "");
         let res_data = self.request.get_exchange_info().await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let symbols = res_data_json["symbols"].as_array().unwrap();
             let market_info = symbols.iter().find(|&item| item["symbol"].as_str().unwrap() == symbol_format);
@@ -231,7 +231,7 @@ impl Platform for BinanceSwap {
     async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
         let symbol_format = utils::format_symbol(symbol.clone(), "");
         let res_data = self.request.get_exchange_info().await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json: serde_json::Value = res_data.data;
             let symbols = res_data_json["symbols"].as_array().unwrap();
             let market_info = symbols.iter().find(|&item| item["symbol"].as_str().unwrap() == symbol_format);
@@ -273,7 +273,7 @@ impl Platform for BinanceSwap {
     async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
         let symbol_format = utils::format_symbol(self.symbol.clone(), "");
         let res_data = self.request.get_order(symbol_format, order_id.parse().unwrap_or(-1), custom_id.to_string()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json: serde_json::Value = res_data.data;
 
             let status = res_data_json["status"].as_str().unwrap();
@@ -301,7 +301,7 @@ impl Platform for BinanceSwap {
     async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
         let symbol_format = utils::format_symbol(self.symbol.clone(), "");
         let res_data = self.request.get_open_orders(symbol_format).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let order_info: Vec<_> = res_data_json.iter().filter(|item| item["contract"].as_str().unwrap_or("") == self.symbol).collect();
             let result = order_info.iter().map(|&item| {

standard/src/bitget_swap.rs

@@ -97,7 +97,7 @@ impl Platform for BitgetSwap {
 
     async fn get_server_time(&mut self) -> Result<String, Error> {
         let res_data = self.request.get_server_time().await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let result = res_data_json["serverTime"].as_str().unwrap().to_string();
             Ok(result)
@@ -109,7 +109,7 @@ impl Platform for BitgetSwap {
     async fn get_account(&mut self) -> Result<Account, Error> {
         let response = self.request.get_account_info().await;
 
-        if response.code == "200" {
+        if response.code == 200 {
             for data in response.data.as_array().unwrap() {
                 if data["marginCoin"].as_str().unwrap() != "USDT" {
                     continue
@@ -150,7 +150,7 @@ impl Platform for BitgetSwap {
         let response = self.request.get_all_position(params).await;
         info!(?response);
 
-        if response.code != "200" {
+        if response.code != 200 {
             return Err(Error::new(ErrorKind::NotFound, format!("bitget_swap 获取仓位异常{:?}", response).to_string()))
         }
 
@@ -214,7 +214,7 @@ impl Platform for BitgetSwap {
     async fn get_ticker_symbol(&mut self, symbol: String) -> Result<Ticker, Error> {
         let symbol_format = utils::format_symbol(symbol.clone(), "");
         let res_data = self.request.get_tickers(symbol_format).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let ticker_info = res_data_json[0].clone();
             let time = (Decimal::from_str(&*ticker_info["ts"].as_str().unwrap()).unwrap() / dec!(1000)).floor().to_i64().unwrap();
@@ -241,7 +241,7 @@ impl Platform for BitgetSwap {
         let symbol_format = utils::format_symbol(symbol.clone(), "");
         let response = self.request.get_contracts(symbol_format.clone()).await;
 
-        if response.code == "200" {
+        if response.code == 200 {
             let res_data_json = response.data.as_array().unwrap();
             let market_info = res_data_json[0].clone();
 
@@ -292,7 +292,7 @@ impl Platform for BitgetSwap {
 
         let ct_val = self.market.ct_val;
         let response = self.request.get_order(params).await;
-        if response.code == "200" {
+        if response.code == 200 {
             let res_data_json = response.data;
             let result = format_order_item(res_data_json, ct_val);
             Ok(result)
@@ -306,7 +306,7 @@ impl Platform for BitgetSwap {
         // let symbol_format = utils::format_symbol(self.symbol.clone(), "");
         // let ct_val = self.market.ct_val;
         // let res_data = self.request.get_unfilled_orders(symbol_format.to_string(), "".to_string(), "".to_string(), "".to_string(), "100".to_string(), "".to_string()).await;
-        // if res_data.code == "200" {
+        // if res_data.code == 200 {
         //     let res_data_str = &res_data.data;
         //     let res_data_json: Vec<serde_json::Value> = serde_json::from_str(res_data_str).unwrap();
         //     let result = res_data_json.iter().map(|item| format_order_item(item.clone(), ct_val)).collect();
@@ -361,7 +361,7 @@ impl Platform for BitgetSwap {
             _ => { panic!("bitget_usdt_swap 下单参数错误"); }
         };
         let res_data = self.request.swap_order(params).await;
-        if res_data.code != "200" {
+        if res_data.code != 200 {
             return Err(Error::new(ErrorKind::Other, res_data.to_string()))
         }
 
@@ -391,7 +391,7 @@ impl Platform for BitgetSwap {
         let response = self.request.cancel_order(params).await;
 
         // 取消失败，进行报错
-        if response.code != "200" {
+        if response.code != 200 {
             return Err(Error::new(ErrorKind::NotFound, response.to_string()));
         }
 
@@ -417,7 +417,7 @@ impl Platform for BitgetSwap {
     async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
         let response = self.request.get_pending_orders().await;
         info!(?response);
-        if response.code == "200" {
+        if response.code == 200 {
             let mut result = vec![];
             let symbol_format = utils::format_symbol(self.symbol.clone(), "");
 
@@ -432,7 +432,7 @@ impl Platform for BitgetSwap {
                         "orderId": order_id,
                     });
                     let cancel_res_data = self.request.cancel_order(params).await;
-                    if cancel_res_data.code == "200" {
+                    if cancel_res_data.code == 200 {
                         let cancel_res_data_json = cancel_res_data.data;
                         result.push(Order {
                             id: cancel_res_data_json["orderId"].as_str().unwrap().to_string(),
@@ -476,7 +476,7 @@ impl Platform for BitgetSwap {
         });
         let response = self.request.set_position_mode(params).await;
 
-        if response.code != "200" {
+        if response.code != 200 {
             return Err(Error::new(ErrorKind::Other, format!("设置持仓模式失败:{:?}", response).to_string()))
         }
 
@@ -492,7 +492,7 @@ impl Platform for BitgetSwap {
         });
         let response = self.request.set_leverage(params).await;
 
-        if response.code != "200" {
+        if response.code != 200 {
             return Err(Error::new(ErrorKind::Other, format!("设置杠杆失败:{:?}", response).to_string()))
         }
 
@@ -507,7 +507,7 @@ impl Platform for BitgetSwap {
         Err(Error::new(ErrorKind::NotFound, "bitget_swap wallet_transfers：该交易所方法未实现".to_string()))
         // let coin_format = coin.to_string().to_uppercase();
         // let res_data = self.request.wallet_transfer(from.to_string(), to.to_string(), amount.to_string(), coin_format.clone(), "".to_string(), "".to_string()).await;
-        // if res_data.code == "200" {
+        // if res_data.code == 200 {
         //     let res_data_str = &res_data.data;
         //     let result = res_data_str.clone();
         //     Ok(result)

standard/src/bybit_swap.rs

@@ -103,7 +103,7 @@ impl Platform for BybitSwap {
     // 获取服务器时间
     async fn get_server_time(&mut self) -> Result<String, Error> {
         let res_data = self.request.get_server_time().await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let result = res_data.data["server_time"].to_string();
             Ok(result)
         } else {
@@ -114,7 +114,7 @@ impl Platform for BybitSwap {
     async fn get_account(&mut self) -> Result<Account, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_account_balance(symbol_array[1].parse().unwrap()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let arr_infos: Vec<Value> = from_value(res_data.data["list"].clone()).unwrap();
             if arr_infos.len() < 1usize{
                 return Err(Error::new(ErrorKind::NotFound, format!("{} 无账户信息", symbol_array[1])));
@@ -150,7 +150,7 @@ impl Platform for BybitSwap {
         let symbol = self.symbol_uppercase.clone();
         let ct_val = self.market.ct_val;
         let res_data = self.request.get_positions(symbol, "".to_string()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let result = res_data.data["list"].as_array().unwrap().iter().map(|item| { format_position_item(item, ct_val) }).collect();
             Ok(result)
         } else {
@@ -162,7 +162,7 @@ impl Platform for BybitSwap {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let ct_val = self.market.ct_val;
         let res_data = self.request.get_positions("".to_string(), symbol_array[1].to_string().to_uppercase()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let result = res_data.data["list"].as_array().unwrap().iter().map(|item| { format_position_item(item, ct_val) }).collect();
             Ok(result)
         } else {
@@ -173,7 +173,7 @@ impl Platform for BybitSwap {
     async fn get_ticker(&mut self) -> Result<Ticker, Error> {
         let symbol = self.symbol_uppercase.clone();
         let res_data = self.request.get_tickers(symbol).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let list :Vec<SwapTicker> = from_value(res_data.data["list"].clone()).unwrap_or(Vec::new());
 
             if list.len() < 1usize {
@@ -198,7 +198,7 @@ impl Platform for BybitSwap {
     async fn get_ticker_symbol(&mut self, symbol: String) -> Result<Ticker, Error> {
         let symbol_upper = symbol.replace("_", "").to_uppercase();
         let res_data = self.request.get_tickers(symbol_upper.clone()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let list: Vec<SwapTicker> = from_value(res_data.data["list"].clone()).unwrap();
             let ticker_info = list.iter().find(|&item| item.symbol == symbol_upper);
 
@@ -228,7 +228,7 @@ impl Platform for BybitSwap {
     async fn get_market(&mut self) -> Result<Market, Error> {
         let symbol = self.symbol_uppercase.clone();
         let res_data = self.request.get_instruments_info(symbol.clone()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let arr_data: Vec<Value> = from_value(res_data.data["list"].clone()).unwrap();
             let market_info = arr_data.iter().find(|&item| item["symbol"].as_str().unwrap() == symbol);
             match market_info {
@@ -276,7 +276,7 @@ impl Platform for BybitSwap {
     async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
         let symbol = symbol.replace("_", "").to_uppercase();
         let res_data = self.request.get_instruments_info(symbol.clone()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let arr_data: Vec<Value> = from_value(res_data.data["list"].clone()).unwrap();
             let market_info = arr_data.iter().find(|item| item["symbol"].as_str().unwrap() == symbol);
             match market_info {
@@ -327,7 +327,7 @@ impl Platform for BybitSwap {
         let ct_val = self.market.ct_val;
         let id = if !custom_id.trim().eq("") { format!("t-{}", custom_id) } else { String::new() };
         let res_data = self.request.get_order(symbol, order_id.parse().unwrap(), id).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json: Value = res_data.data["list"].clone();
             if res_data_json.is_array() && res_data_json.as_array().unwrap().len() == 0 {
                 return Err(Error::new(ErrorKind::Other, "没有该订单！"));
@@ -384,7 +384,7 @@ impl Platform for BybitSwap {
             _ => { error!("下单参数错误"); }
         };
         let res_data = self.request.swap_order(params).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let result = format_new_order_item(res_data.data, price, size);
             Ok(result)
         } else {
@@ -438,7 +438,7 @@ impl Platform for BybitSwap {
             _ => { error!("下单参数错误"); }
         };
         let res_data = self.request.swap_order(params.clone()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let result = format_new_order_item(res_data.data, price, size);
             Ok(result)
         } else {
@@ -451,7 +451,7 @@ impl Platform for BybitSwap {
         let symbol = self.symbol_uppercase.clone();
         let id = format!("t-{}", custom_id);
         let res_data = self.request.cancel_order(symbol, String::from(order_id), id.clone()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let result = format_cancel_order_item(res_data.data);
             Ok(result)
         } else {
@@ -462,7 +462,7 @@ impl Platform for BybitSwap {
     async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
         let symbol = self.symbol_uppercase.clone();
         let res_data = self.request.cancel_orders(symbol).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_arr: Vec<Value> = from_value(res_data.data).unwrap();
             let result = res_arr.iter().map(|item| format_cancel_order_item(item.clone())).collect();
             Ok(result)
@@ -474,7 +474,7 @@ impl Platform for BybitSwap {
     async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
         let symbol = self.symbol_uppercase.clone();
         let res_data = self.request.cancel_orders(symbol).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_arr: Vec<Value> = from_value(res_data.data["list"].clone()).unwrap();
             let result = res_arr.iter().map(|item| format_cancel_order_item(item.clone())).collect();
             Ok(result)
@@ -499,7 +499,7 @@ impl Platform for BybitSwap {
             mod_num = 3;
         }
         let res_data = self.request.set_position_mode(coin_format, mod_num).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             Ok(res_data.data.to_string())
         } else {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))
@@ -510,7 +510,7 @@ impl Platform for BybitSwap {
     async fn set_dual_leverage(&mut self, leverage: &str) -> Result<String, Error> {
         let symbol = self.symbol_uppercase.clone();
         let res_data = self.request.set_leverage(symbol, leverage.to_string()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             Ok(res_data.data.to_string())
         } else {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))
@@ -523,7 +523,7 @@ impl Platform for BybitSwap {
     async fn wallet_transfers(&mut self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> {
         // let coin_format = coin.to_string().to_lowercase();
         // let res_data = self.request.wallet_transfers(coin_format.clone(), from.to_string(), to.to_string(), amount.to_string(), coin_format.clone()).await;
-        // if res_data.code == "200" {
+        // if res_data.code == 200 {
         //     let res_data_str = &res_data.data;
         //     let result = res_data_str.clone();
         //     Ok(result)

standard/src/gate_swap.rs

@@ -89,7 +89,7 @@ impl Platform for GateSwap {
     // 获取服务器时间
     async fn get_server_time(&mut self) -> Result<String, Error> {
         let res_data = self.request.get_server_time().await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json: serde_json::Value = res_data.data;
             let result = res_data_json["server_time"].to_string();
             Ok(result)
@@ -101,7 +101,7 @@ impl Platform for GateSwap {
     async fn get_account(&mut self) -> Result<Account, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_account(symbol_array[1].to_string().to_lowercase()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json: serde_json::Value = res_data.data;
             let balance = Decimal::from_str(res_data_json["total"].as_str().unwrap()).unwrap();
             let available_balance = Decimal::from_str(res_data_json["available"].as_str().unwrap()).unwrap();
@@ -130,7 +130,7 @@ impl Platform for GateSwap {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let ct_val = self.market.ct_val;
         let res_data = self.request.get_position(symbol_array[1].to_string().to_lowercase(), self.symbol.clone()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let result = res_data_json.iter().map(|item| { format_position_item(item, ct_val) }).collect();
             Ok(result)
@@ -142,7 +142,7 @@ impl Platform for GateSwap {
     async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_user_position(symbol_array[1].to_string().to_lowercase()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let result = res_data_json.iter().map(|item| { format_position_item(item, Decimal::ONE) }).collect();
             Ok(result)
@@ -154,7 +154,7 @@ impl Platform for GateSwap {
     async fn get_ticker(&mut self) -> Result<Ticker, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_ticker(symbol_array[1].to_string().to_lowercase()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let ticker_info = res_data_json.iter().find(|item| item["contract"].as_str().unwrap() == self.symbol);
             match ticker_info {
@@ -184,7 +184,7 @@ impl Platform for GateSwap {
         let symbol_upper = symbol.to_uppercase();
         let symbol_array: Vec<&str> = symbol_upper.split("_").collect();
         let res_data = self.request.get_ticker(symbol_array[1].to_string().to_lowercase()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let ticker_info = res_data_json.iter().find(|item| item["contract"].as_str().unwrap() == symbol_upper);
             match ticker_info {
@@ -213,7 +213,7 @@ impl Platform for GateSwap {
     async fn get_market(&mut self) -> Result<Market, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_market_details(symbol_array[1].to_string().to_lowercase()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let market_info = res_data_json.iter().find(|item| item["name"].as_str().unwrap() == self.symbol);
             match market_info {
@@ -261,7 +261,7 @@ impl Platform for GateSwap {
         let symbol_upper = symbol.to_uppercase();
         let symbol_array: Vec<&str> = symbol_upper.split("_").collect();
         let res_data = self.request.get_market_details(symbol_array[1].to_string().to_lowercase()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let market_info = res_data_json.iter().find(|item| item["name"].as_str().unwrap() == symbol_upper);
             match market_info {
@@ -311,7 +311,7 @@ impl Platform for GateSwap {
         let ct_val = self.market.ct_val;
         let id = if order_id.eq("") { format!("t-{}", custom_id) } else { order_id.to_string() };
         let res_data = self.request.get_order_details(symbol_array[1].to_string().to_lowercase(), id).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json: serde_json::Value = res_data.data;
             let result = format_order_item(res_data_json, ct_val);
             Ok(result)
@@ -324,7 +324,7 @@ impl Platform for GateSwap {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let ct_val = self.market.ct_val;
         let res_data = self.request.get_orders(symbol_array[1].to_string().to_lowercase(), status.to_string()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let order_info: Vec<_> = res_data_json.iter().filter(|item| item["contract"].as_str().unwrap_or("") == self.symbol).collect();
             let result = order_info.iter().map(|&item| format_order_item(item.clone(), ct_val)).collect();
@@ -366,7 +366,7 @@ impl Platform for GateSwap {
             _ => { error!("下单参数错误"); }
         };
         let res_data = self.request.swap_order(symbol_array[1].to_string().to_lowercase(), params).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json: serde_json::Value = res_data.data;
             let result = format_order_item(res_data_json, ct_val);
             Ok(result)
@@ -407,7 +407,7 @@ impl Platform for GateSwap {
             _ => { error!("下单参数错误"); }
         };
         let res_data = self.request.swap_order(symbol_array[1].to_string().to_lowercase(), params).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json: serde_json::Value = res_data.data;
             let result = format_order_item(res_data_json, ct_val);
             Ok(result)
@@ -423,7 +423,7 @@ impl Platform for GateSwap {
         let settle = symbol_array[1].to_string().to_lowercase();
         let id = if order_id.eq("") { format!("t-{}", custom_id) } else { order_id.to_string() };
         let res_data = self.request.cancel_order(settle, id.to_string()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json: serde_json::Value = res_data.data;
             let result = format_order_item(res_data_json, ct_val);
             Ok(result)
@@ -436,7 +436,7 @@ impl Platform for GateSwap {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let ct_val = self.market.ct_val;
         let res_data = self.request.cancel_orders(symbol_array[1].to_string().to_lowercase(), self.symbol.to_string()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let result = res_data_json.iter().map(|item| format_order_item(item.clone(), ct_val)).collect();
             Ok(result)
@@ -449,12 +449,12 @@ impl Platform for GateSwap {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let ct_val = self.market.ct_val;
         let orders_res_data = self.request.get_orders(symbol_array[1].to_string().to_lowercase(), "open".to_string()).await;
-        if orders_res_data.code == "200" {
+        if orders_res_data.code == 200 {
             let mut result = vec![];
             let orders_res_data_json = orders_res_data.data.as_array().unwrap();
             for order in orders_res_data_json {
                 let cancel_res_data = self.request.cancel_orders(symbol_array[1].to_string().to_lowercase(), order["contract"].as_str().unwrap().to_string()).await;
-                if cancel_res_data.code == "200" {
+                if cancel_res_data.code == 200 {
                     let cancel_res_data_json = cancel_res_data.data.as_array().unwrap();
                     for cancel in cancel_res_data_json {
                         result.push(format_order_item(cancel.clone(), ct_val))
@@ -528,7 +528,7 @@ impl Platform for GateSwap {
         let symbol_split: Vec<&str> = binding.split("_").collect();
         let base_coin = symbol_split[1].to_string();
         let response_data = self.request.place_price_order(base_coin, params).await;
-        if response_data.code == "200" {
+        if response_data.code == 200 {
             Ok(response_data.data)
         } else {
             Err(Error::new(ErrorKind::Other, response_data.to_string()))
@@ -541,7 +541,7 @@ impl Platform for GateSwap {
         let base_coin = symbol_split[1].to_string();
 
         let response_data = self.request.cancel_price_order(base_coin, order_id.to_string()).await;
-        if response_data.code == "200" {
+        if response_data.code == 200 {
             Ok(response_data.data)
         } else {
             Err(Error::new(ErrorKind::Other, response_data.to_string()))
@@ -552,7 +552,7 @@ impl Platform for GateSwap {
     async fn set_dual_mode(&mut self, coin: &str, is_dual_mode: bool) -> Result<String, Error> {
         let coin_format = coin.to_string().to_lowercase();
         let res_data = self.request.setting_dual_mode(coin_format, is_dual_mode).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_str = &res_data.data;
             let result = res_data_str.clone();
             Ok(result.to_string())
@@ -565,7 +565,7 @@ impl Platform for GateSwap {
     async fn set_dual_leverage(&mut self, leverage: &str) -> Result<String, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.setting_dual_leverage(symbol_array[1].to_string().to_lowercase(), self.symbol.to_string(), leverage.to_string()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_str = &res_data.data;
             let result = res_data_str.clone();
             Ok(result.to_string())
@@ -580,7 +580,7 @@ impl Platform for GateSwap {
     async fn wallet_transfers(&mut self, coin: &str, from: &str, to: &str, amount: Decimal) -> Result<String, Error> {
         let coin_format = coin.to_string().to_lowercase();
         let res_data = self.request.wallet_transfers(coin_format.clone(), from.to_string(), to.to_string(), amount.to_string(), coin_format.clone()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_str = &res_data.data;
             let result = res_data_str.clone();
             Ok(result.to_string())

standard/src/kucoin_swap.rs

@@ -81,7 +81,7 @@ impl Platform for KucoinSwap {
     // 获取服务器时间
     async fn get_server_time(&mut self) -> Result<String, Error> {
         let res_data = self.request.get_server_time().await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             Ok(res_data.data.to_string())
         } else {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))
@@ -92,7 +92,7 @@ impl Platform for KucoinSwap {
         let symbol_mapper = utils::symbol_enter_mapper(ExchangeEnum::KucoinSwap, self.symbol.as_str());
         let symbol_array: Vec<&str> = symbol_mapper.split("_").collect();
         let res_data = self.request.get_account(symbol_array[1].to_string()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
 
             let balance = Decimal::from_f64(res_data_json["marginBalance"].as_f64().unwrap()).unwrap();
@@ -122,7 +122,7 @@ impl Platform for KucoinSwap {
         let symbol_format = format!("{}M", utils::format_symbol(symbol_mapper.clone(), ""));
         let ct_val = self.market.ct_val;
         let res_data = self.request.get_position(symbol_format).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let result = kucoin_handle::format_position_item(&res_data.data, &ct_val);
             Ok(vec![result])
         } else {
@@ -134,7 +134,7 @@ impl Platform for KucoinSwap {
         let symbol_mapper = utils::symbol_enter_mapper(ExchangeEnum::KucoinSwap, self.symbol.as_str());
         let symbol_array: Vec<&str> = symbol_mapper.split("_").collect();
         let res_data = self.request.get_positions(symbol_array[1].to_string()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let mut result = Vec::new();
             for item in res_data_json.iter() {
@@ -150,7 +150,7 @@ impl Platform for KucoinSwap {
         let symbol_mapper = utils::symbol_enter_mapper(ExchangeEnum::KucoinSwap, self.symbol.as_str());
         let symbol_format = format!("{}M", utils::format_symbol(symbol_mapper.clone(), ""));
         let res_data = self.request.get_ticker(symbol_format).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let ticker_info = res_data_json;
             let time = (Decimal::from_str(&*ticker_info["ts"].to_string()).unwrap() / dec!(1000000)).floor().to_i64().unwrap();
@@ -174,7 +174,7 @@ impl Platform for KucoinSwap {
         let symbol_mapper = utils::symbol_enter_mapper(ExchangeEnum::KucoinSwap, symbol.as_str());
         let symbol_format = format!("{}M", utils::format_symbol(symbol_mapper, ""));
         let res_data = self.request.get_ticker(symbol_format).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let ticker_info = res_data_json;
             let time = (Decimal::from_str(&*ticker_info["ts"].to_string()).unwrap() / dec!(1000000)).floor().to_i64().unwrap();
@@ -197,7 +197,7 @@ impl Platform for KucoinSwap {
         let symbol_mapper = utils::symbol_enter_mapper(ExchangeEnum::KucoinSwap, self.symbol.as_str());
         let symbol_format = format!("{}M", utils::format_symbol(symbol_mapper.clone(), ""));
         let res_data = self.request.get_market_details().await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
 
             let market_info = res_data_json.iter().find(|item| item["symbol"].as_str().unwrap() == symbol_format);
@@ -246,7 +246,7 @@ impl Platform for KucoinSwap {
         let symbol_mapper = utils::symbol_enter_mapper(ExchangeEnum::KucoinSwap, symbol.as_str());
         let symbol_format = format!("{}M", utils::format_symbol(symbol_mapper.clone(), ""));
         let res_data = self.request.get_market_details().await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data.as_array().unwrap();
             let market_info = res_data_json.iter().find(|item| item["symbol"].as_str().unwrap() == symbol_format);
             match market_info {
@@ -293,7 +293,7 @@ impl Platform for KucoinSwap {
     async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
         let ct_val = self.market.ct_val;
         let res_data = self.request.get_orders_details(order_id.to_string(), custom_id.to_string()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let result = format_order_item(res_data_json, ct_val);
             Ok(result)
@@ -307,7 +307,7 @@ impl Platform for KucoinSwap {
         let symbol_format = format!("{}M", utils::format_symbol(symbol_mapper.clone(), ""));
         let ct_val = self.market.ct_val;
         let res_data = self.request.get_orders(status.to_string(), symbol_format.clone()).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let order_list = res_data_json["items"].as_array().unwrap().clone();
             let order_info: Vec<_> = order_list.iter().filter(|item| item["symbol"].as_str().unwrap_or("") == symbol_format.clone()).collect();
@@ -349,7 +349,7 @@ impl Platform for KucoinSwap {
         };
 
         let res_data = self.request.swap_order(params).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let id = res_data_json["orderId"].as_str().unwrap().to_string();
             let result = Order {
@@ -401,7 +401,7 @@ impl Platform for KucoinSwap {
         };
 
         let res_data = self.request.swap_order(params).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let id = res_data_json["orderId"].as_str().unwrap().to_string();
             let result = Order {
@@ -427,7 +427,7 @@ impl Platform for KucoinSwap {
             error!("Kucoin：撤销订单错误,该交易所为提供自定义订单号撤销订单!\ncancel_order:order_id={:?},custom_id={:?}", order_id, custom_id);
             panic!("Kucoin：撤销订单错误,该交易所为提供自定义订单号撤销订单!\ncancel_order:order_id={:?},custom_id={:?}", order_id, custom_id)
         }
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let cancel_ids = res_data_json["cancelledOrderIds"].as_array().unwrap();
             let id = cancel_ids[0].as_str().unwrap().to_string();
@@ -452,7 +452,7 @@ impl Platform for KucoinSwap {
         let symbol_mapper = utils::symbol_enter_mapper(ExchangeEnum::KucoinSwap, self.symbol.as_str());
         let symbol_format = format!("{}M", utils::format_symbol(symbol_mapper.clone(), ""));
         let res_data = self.request.cancel_orders(symbol_format).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let cancel_ids = res_data_json["cancelledOrderIds"].as_array().unwrap();
             let result = cancel_ids.iter().map(|item|
@@ -476,7 +476,7 @@ impl Platform for KucoinSwap {
 
     async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
         let res_data = self.request.cancel_order_all().await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             let res_data_json = res_data.data;
             let cancel_ids = res_data_json["cancelledOrderIds"].as_array().unwrap();
             let result = cancel_ids.iter().map(|item|
@@ -518,7 +518,7 @@ impl Platform for KucoinSwap {
         let symbol_mapper = utils::symbol_enter_mapper(ExchangeEnum::KucoinSwap, self.symbol.as_str());
         let symbol_format = format!("{}M", utils::format_symbol(symbol_mapper.clone(), ""));
         let res_data = self.request.auto_deposit_status(symbol_format, status).await;
-        if res_data.code == "200" {
+        if res_data.code == 200 {
             Ok(res_data.data.to_string())
         } else {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))

strategy/src/bybit_usdt_swap.rs

@@ -142,7 +142,7 @@ async fn on_private_data(core_arc_clone: Arc<Mutex<Core>>, ct_val: &Decimal, run
 }
 
 async fn on_public_data(core_arc_clone: Arc<Mutex<Core>>, update_flag_u: &mut Decimal, response: ResponseData) {
-    if response.code.as_str() != "200" {
+    if response.code != 200 {
         return;
     }
 

strategy/src/gate_swap.rs

@@ -31,7 +31,7 @@ pub async fn gate_swap_run(is_shutdown_arc: Arc<AtomicBool>,
     if is_trade {
         // 获取user_id
         let res_data = gate_exc.wallet_fee().await;
-        assert_eq!(res_data.code, "200", "获取gate交易所参数 user_id 失败， 启动失败！");
+        assert_eq!(res_data.code, 200, "获取gate交易所参数 user_id 失败， 启动失败！");
 
         let wallet_obj = res_data.data;
         info!(?wallet_obj);