修改订单处理

standard/Cargo.toml

@@ -14,4 +14,6 @@ serde_json = "1.0.105"
 rust_decimal = "1.32.0"
 rust_decimal_macros = "1.32.0"
 chrono = "0.4.30"
-futures = "0.3"
+futures = "0.3"
+tracing = "0.1"
+tracing-subscriber = "0.3.17"

standard/src/binance_spot.rs

@@ -29,6 +29,7 @@ impl BinanceSpot {
     }
 }
 
+
 #[async_trait]
 impl Platform for BinanceSpot {
     // 获取交易所模式

standard/src/exchange.rs

@@ -48,6 +48,8 @@ pub enum ExchangeEnum {
 /// params.insert("access_key".to_string(), "your_access_key".to_string());
 /// params.insert("access_key".to_string(), "your_secret_key".to_string());
 /// let exchange = Exchange::new(ExchangeEnum::BinanceSwap, "BTC_USDT".to_string(), false, params);
+
+#[derive(Debug)]
 pub struct Exchange;
 
 impl Exchange {

standard/src/gate_handle.rs

@@ -38,34 +38,45 @@ pub fn handle_account_info(res_data: ResponseData, symbol: String) -> Result<Acc
 }
 
 // 处理order信息
-pub fn handle_order(res_data: ResponseData) -> SpecialOrder {
+pub fn handle_order(res_data: ResponseData, multiplier: Decimal) -> SpecialOrder {
     let res_data_str = res_data.data;
     let res_data_json: Vec<serde_json::Value> = serde_json::from_str(&*res_data_str).unwrap();
     let mut order_info = Vec::new();
     for item in res_data_json.iter() {
         let status = item["status"].as_str().unwrap_or("");
+        let id = item["id"].to_string();
+        let custom_id = item["text"].as_str().unwrap_or("").parse().unwrap();
+        let price = item["price"].as_str().unwrap_or("0").parse().unwrap_or(dec!(0));
+        let size = item["size"].to_string().parse().unwrap_or(dec!(0));
+        let left = item["left"].to_string().parse().unwrap_or(dec!(0));
+        let fill_price = item["fill_price"].to_string().parse().unwrap_or(dec!(0));
+        let order_type = "limit".to_string();
+
+        let amount = size * multiplier;
+        let deal_amount = (amount - left) * multiplier;
+        let avg_price = fill_price / deal_amount;
         if status == "open" {
             let order = Order {
-                id: item["id"].to_string(),
-                custom_id: item["text"].as_str().unwrap_or("").parse().unwrap(),
-                price: item["price"].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
-                amount: item["size"].to_string().parse().unwrap_or(dec!(0)),
-                deal_amount: Default::default(),
-                avg_price: Default::default(),
+                id,
+                custom_id,
+                price,
+                amount,
+                deal_amount: dec!(0),
+                avg_price: dec!(0),
                 status: "NEW".to_string(),
-                order_type: "".to_string(),
+                order_type,
             };
             order_info.push(order);
         } else if status == "finished" {
             let order = Order {
-                id: item["id"].to_string(),
-                custom_id: item["text"].as_str().unwrap_or("").parse().unwrap(),
-                price: item["price"].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
-                amount: item["size"].to_string().parse().unwrap_or(dec!(0)),
-                deal_amount: Default::default(),
-                avg_price: Default::default(),
+                id,
+                custom_id,
+                price,
+                amount,
+                deal_amount,
+                avg_price,
                 status: "REMOVE".to_string(),
-                order_type: "".to_string(),
+                order_type,
             };
             order_info.push(order);
         }

standard/src/gate_swap.rs

@@ -250,8 +250,7 @@ impl Platform for GateSwap {
             }
             "pd" => {
                 params["reduce_only"] = json!(true);
-                params["size"] = json!(0);
-                params["auto_size"] = json!("close_long".to_string());
+                params["size"] = serde_json::Value::from((-size).to_i64());
             }
             "kk" => {
                 params["reduce_only"] = json!(false);
@@ -259,8 +258,7 @@ impl Platform for GateSwap {
             }
             "pk" => {
                 params["reduce_only"] = json!(true);
-                params["size"] = json!(0);
-                params["auto_size"] = json!("close_short".to_string());
+                params["size"] = json!(size.to_i64());
             }
             _ => { println!("下单参数错误"); }
         };

standard/src/kucoin_handle.rs

@@ -38,34 +38,46 @@ pub fn handle_account_info(res_data: ResponseData, symbol: String) -> Result<Acc
 }
 
 // 处理order信息
-pub fn handle_order(res_data: ResponseData) -> SpecialOrder {
+pub fn handle_order(res_data: ResponseData, multiplier: Decimal) -> SpecialOrder {
     let res_data_str = res_data.data;
     let res_data_json: Vec<serde_json::Value> = serde_json::from_str(&*res_data_str).unwrap();
     let mut order_info = Vec::new();
     for item in res_data_json.iter() {
-        let status = item["status"].as_str().unwrap_or("");
+        let id = item["id"].as_str().unwrap_or("").parse().unwrap();
+        let custom_id = item["clientOid"].as_str().unwrap_or("").parse().unwrap();
+        let price = item["price"].as_str().unwrap_or("0").parse().unwrap_or(dec!(0));
+        let status = item["type"].as_str().unwrap_or("");
+        let size = item["size"].to_string().parse().unwrap_or(dec!(0));
+        let order_type = item["orderType"].as_str().unwrap_or("0").parse().unwrap_or("".to_string());
+        let filled_size = item["filledSize"].to_string().parse().unwrap_or(dec!(0));
+        let match_price = item["matchPrice"].to_string().parse().unwrap_or(dec!(0));
+
+        let amount = size * multiplier;
+        let deal_amount = filled_size * multiplier;
+        let deal_price = if match_price != dec!(0) { match_price } else { price };
+        let avg_price = deal_price / filled_size;
         if status == "open" {
             let order = Order {
-                id: item["id"].to_string(),
-                custom_id: item["text"].as_str().unwrap_or("").parse().unwrap(),
-                price: item["price"].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
-                amount: item["size"].to_string().parse().unwrap_or(dec!(0)),
-                deal_amount: Default::default(),
-                avg_price: Default::default(),
+                id,
+                custom_id,
+                price,
+                amount,
+                deal_amount: dec!(0),
+                avg_price: dec!(0),
                 status: "NEW".to_string(),
-                order_type: "".to_string(),
+                order_type,
             };
             order_info.push(order);
         } else if ["filled", "canceled"].contains(&status) {
             let order = Order {
-                id: item["id"].to_string(),
-                custom_id: item["text"].as_str().unwrap_or("").parse().unwrap(),
-                price: item["price"].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
-                amount: item["size"].to_string().parse().unwrap_or(dec!(0)),
-                deal_amount: Default::default(),
-                avg_price: Default::default(),
+                id,
+                custom_id,
+                price,
+                amount,
+                deal_amount,
+                avg_price,
                 status: "REMOVE".to_string(),
-                order_type: "".to_string(),
+                order_type,
             };
             order_info.push(order);
         }

standard/src/lib.rs

@@ -327,6 +327,7 @@ pub struct Position {
 ///
 /// exchange.subscribe_account();
 /// ```
+
 #[async_trait]
 pub trait Platform {
     // 获取当前交易所交易模式

standard/tests/libs_test.rs

@@ -1,15 +1,17 @@
 use std::collections::BTreeMap;
 use std::env;
 use rust_decimal_macros::dec;
+use tracing::{instrument, trace};
 use exchanges::proxy;
 use standard::{Platform};
 use standard::utils;
 use standard::exchange::{Exchange, ExchangeEnum};
 
 // 创建交易所实体方法
+#[instrument(skip(exchange), level = "TRACE")]
 fn test_new_exchange(exchange: ExchangeEnum) -> Box<dyn Platform> {
     if proxy::ParsingDetail::http_enable_proxy() {
-        println!("检测有代理配置，配置走代理")
+        trace!("检测有代理配置，配置走代理");
     }
     match exchange {
         ExchangeEnum::BinanceSwap => {
@@ -59,29 +61,43 @@ fn test_new_exchange(exchange: ExchangeEnum) -> Box<dyn Platform> {
 
 // 测试获取Binance交易所期货实体
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_binance_swap_account() {
+    global::log_utils::init_log_with_trace();
+
     let binance_swap_exchange = test_new_exchange(ExchangeEnum::BinanceSwap);
-    println!("exchange: {:?}", binance_swap_exchange.get_self_exchange());
-    println!("is_colo: {:?}", binance_swap_exchange.get_self_is_colo());
-    println!("params: {:?}", binance_swap_exchange.get_self_params());
+    let self_exchange = binance_swap_exchange.get_self_exchange();
+    let self_is_colo = binance_swap_exchange.get_self_is_colo();
+    let self_params = binance_swap_exchange.get_self_params();
+    trace!(?self_exchange);
+    trace!(?self_is_colo);
+    trace!(?self_params);
 }
 
 // 测试获取Binance交易所现货实体
 #[tokio::test]
 async fn test_binance_spot_account() {
+    global::log_utils::init_log_with_trace();
+
     let binance_spot_exchange = test_new_exchange(ExchangeEnum::BinanceSpot);
-    println!("exchange: {:?}", binance_spot_exchange.get_self_exchange());
-    println!("is_colo: {:?}", binance_spot_exchange.get_self_is_colo());
-    println!("params: {:?}", binance_spot_exchange.get_self_params());
+    let self_exchange = binance_spot_exchange.get_self_exchange();
+    let self_is_colo = binance_spot_exchange.get_self_is_colo();
+    let self_params = binance_spot_exchange.get_self_params();
+    trace!(?self_exchange);
+    trace!(?self_is_colo);
+    trace!(?self_params);
 }
 
 // 测试获取Gate交易所期货实体
 #[tokio::test]
 async fn test_gate_swap_account() {
     let gate_swap_exchange = test_new_exchange(ExchangeEnum::GateSwap);
-    println!("exchange: {:?}", gate_swap_exchange.get_self_exchange());
-    println!("is_colo: {:?}", gate_swap_exchange.get_self_is_colo());
-    println!("params: {:?}", gate_swap_exchange.get_self_params());
+    let self_exchange = gate_swap_exchange.get_self_exchange();
+    let self_is_colo = gate_swap_exchange.get_self_is_colo();
+    let self_params = gate_swap_exchange.get_self_params();
+    trace!(?self_exchange);
+    trace!(?self_is_colo);
+    trace!(?self_params);
 }
 
 // 测试获取Gate交易所现货实体
@@ -195,6 +211,7 @@ async fn test_kucoin_swap_get_position() {
     let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap);
     println!("kucoin_swap get_position:{:?}", kucoin_swap_exchange.get_position().await);
 }
+
 // 测试kucoin 获取所有持仓信息
 #[tokio::test]
 async fn test_kucoin_swap_get_positions() {
@@ -221,4 +238,4 @@ async fn test_kucoin_swap_get_market() {
 async fn test_kucoin_swap_get_order_detail() {
     let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap);
     println!("kucoin_swap get_market:{:?}", kucoin_swap_exchange.get_order_detail("123", "").await);
-}
+}