完成gate下单只能逻辑

修改下单接口

standard/src/binance_spot.rs

@@ -92,11 +92,11 @@ impl Platform for BinanceSpot {
         todo!()
     }
 
-    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _coin: &str, _amount: Decimal) -> Result<Order, Error> {
+    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> {
         todo!()
     }
 
-    async fn cancel_order(&self, _order_id: &str, _is_custom_id: Option<bool>) -> Result<Order, Error> {
+    async fn cancel_order(&self, _order_id: &str, _is_custom_id: bool) -> Result<Order, Error> {
         todo!()
     }
 
@@ -104,7 +104,7 @@ impl Platform for BinanceSpot {
         todo!()
     }
 
-    async fn command_order(&self, order_command: OrderCommand) {
+    async fn command_order(&self, _order_command: OrderCommand) {
         todo!()
     }
 }

standard/src/binance_swap.rs

@@ -108,11 +108,11 @@ impl Platform for BinanceSwap {
         todo!()
     }
 
-    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _coin: &str, _amount: Decimal) -> Result<Order, Error> {
+    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> {
         todo!()
     }
 
-    async fn cancel_order(&self, _order_id: &str, _is_custom_id: Option<bool>,) -> Result<Order, Error> {
+    async fn cancel_order(&self, _order_id: &str, _is_custom_id: bool) -> Result<Order, Error> {
         todo!()
     }
 

standard/src/gate_spot.rs

@@ -2,9 +2,8 @@ use std::collections::BTreeMap;
 use std::io::{Error};
 use async_trait::async_trait;
 use rust_decimal::Decimal;
-use crate::{Platform, ExchangeEnum, Account, gate_handle, Position, PositionModeEnum, Ticker, Market, Order, OrderCommand};
+use crate::{Platform, ExchangeEnum, Account, Position, PositionModeEnum, Ticker, Market, Order, OrderCommand};
 use exchanges::gate_spot_rest::GateSpotRest;
-use exchanges::response_base::ResponseData;
 
 #[allow(dead_code)]
 pub struct GateSpot {
@@ -85,11 +84,11 @@ impl Platform for GateSpot {
         todo!()
     }
 
-    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _coin: &str, _amount: Decimal) -> Result<Order, Error> {
+    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> {
         todo!()
     }
 
-    async fn cancel_order(&self, _order_id: &str, _is_custom_id: Option<bool>) -> Result<Order, Error> {
+    async fn cancel_order(&self, _order_id: &str, _is_custom_id: bool) -> Result<Order, Error> {
         todo!()
     }
 

standard/src/gate_swap.rs

@@ -8,7 +8,7 @@ use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
 use rust_decimal_macros::dec;
 use serde_json::{json};
 use tokio::runtime;
-use crate::{Platform, ExchangeEnum, Account, Position, PositionModeEnum, Ticker, Market, Order, utils, OrderCommand};
+use crate::{Platform, ExchangeEnum, Account, Position, PositionModeEnum, Ticker, Market, Order, OrderCommand};
 use exchanges::gate_swap_rest::GateSwapRest;
 
 #[allow(dead_code)]
@@ -97,7 +97,6 @@ impl Platform for GateSwap {
                 "dual_short" => PositionModeEnum::Short,
                 _ => PositionModeEnum::Both
             };
-            println!("{}", position_info);
             let result = Position {
                 margin_level: position_info["leverage"].as_str().unwrap_or("1").parse().unwrap_or(dec!(0)),
                 amount: position_info["size"].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
@@ -232,10 +231,41 @@ impl Platform for GateSwap {
         }
     }
     // 下单接口
-    async fn take_order(&self, custom_id: &str, origin_side: &str, coin: &str, amount: Decimal) -> Result<Order, Error> {
-        let symbol_format = utils::format_symbol(self.symbol.clone(), "_");
-        let coin_format = coin.to_string().to_lowercase();
-        let res_data = self.request.swap_bazaar_order(custom_id.to_string(), origin_side.to_string(), coin_format.clone(), symbol_format, amount.to_i64().unwrap()).await;
+    async fn take_order(&self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
+        let symbol_array: Vec<&str> = self.symbol.split("_").collect();
+        let mut params = json!({
+            "text": format!("t-my-custom-id_{}", custom_id),
+            "contract": self.symbol.to_string(),
+            "price": price.to_string(),
+        });
+        let size = amount;
+        if price.eq(&dec!(0)) {
+            params["tif"] = json!("ioc".to_string());
+        }
+        match origin_side {
+            "kd" => {
+                params["reduce_only"] = json!(false);
+                params["size"] = json!(size.to_i64());
+            }
+            "pd" => {
+                params["reduce_only"] = json!(true);
+                params["size"] = json!(0);
+                params["auto_size"] = json!("close_long".to_string());
+            }
+            "kk" => {
+                params["reduce_only"] = json!(false);
+                params["size"] = serde_json::Value::from((-size).to_i64());
+            }
+            "pk" => {
+                params["reduce_only"] = json!(true);
+                params["size"] = json!(0);
+                params["auto_size"] = json!("close_short".to_string());
+            }
+            _ => { println!("下单参数错误"); }
+        };
+        println!("{}", params);
+        println!("{}", symbol_array[1].to_string().to_lowercase());
+        let res_data = self.request.swap_order(symbol_array[1].to_string().to_lowercase(), params).await;
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
             let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
@@ -246,10 +276,10 @@ impl Platform for GateSwap {
         }
     }
     // 撤销订单
-    async fn cancel_order(&self, order_id: &str, is_custom_id: Option<bool>) -> Result<Order, Error> {
+    async fn cancel_order(&self, order_id: &str, is_custom_id: bool) -> Result<Order, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let settle = symbol_array[1].to_string().to_lowercase();
-        let id = if is_custom_id.unwrap_or(false) { order_id } else { order_id };
+        let id = if is_custom_id { order_id } else { order_id };
         let res_data = self.request.cancel_order(settle, id.to_string()).await;
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
@@ -286,7 +316,7 @@ impl Platform for GateSwap {
                 let order_id = cancel_clone[&item_clone].get(0).unwrap().clone();
                 let handle = thread::spawn(move || {
                     runtime::Runtime::new().unwrap().block_on(async {
-                        let result = self_clone.cancel_order(&order_id, None).await;
+                        let result = self_clone.cancel_order(&order_id, false).await;
                         match result {
                             Ok(result) => {
                                 println!("{:?}", result);
@@ -303,7 +333,7 @@ impl Platform for GateSwap {
                 let order_id = cancel_clone[&item_clone].get(1).unwrap().clone();
                 let handle = thread::spawn(move || {
                     runtime::Runtime::new().unwrap().block_on(async {
-                        let result = self_clone.cancel_order(&order_id, Option::from(true)).await;
+                        let result = self_clone.cancel_order(&order_id, true).await;
                         match result {
                             Ok(result) => {
                                 println!("{:?}", result);
@@ -319,19 +349,22 @@ impl Platform for GateSwap {
         }
         // 下单指令
         let limits = order_command.limits;
+        let market = self.get_market().await.unwrap();
         for item in limits.keys() {
             let self_clone = self.clone();
             let limits_clone = limits.clone();
             let item_clone = item.clone();
+            let market_clone = market.clone();
             let handle = thread::spawn(move || {
                 runtime::Runtime::new().unwrap().block_on(async {
                     let value = limits_clone[&item_clone].clone();
-                    let cid = value.get(3).unwrap();
+                    let amount = (Decimal::from_str(value.get(0).unwrap()).unwrap() / market_clone.amount_size).floor();
                     let side = value.get(1).unwrap();
-                    let symbol = &item_clone;
-                    let amount = Decimal::from_str(value.get(0).unwrap()).unwrap();
+                    let price = Decimal::from_str(value.get(2).unwrap()).unwrap();
+                    let cid = value.get(3).unwrap();
+
                     //  order_name: [数量，方向，价格，c_id]
-                    let result = self_clone.take_order(cid, side, "usdt", amount).await;
+                    let result = self_clone.take_order(cid, side, price, amount).await;
                     match result {
                         Ok(result) => {
                             println!("{:?}", result);

standard/src/kucoin_swap.rs

@@ -195,9 +195,8 @@ impl Platform for KucoinSwap {
         todo!()
     }
 
-    async fn take_order(&self, custom_id: &str, origin_side: &str, coin: &str, amount: Decimal) -> Result<Order, Error> {
+    async fn take_order(&self, custom_id: &str, origin_side: &str, _price: Decimal, amount: Decimal) -> Result<Order, Error> {
         let symbol_format = utils::format_symbol(self.symbol.clone(), "_");
-        let coin_format = coin.to_string().to_lowercase();
         let res_data = self.request.swap_bazaar_order(custom_id.to_string(), symbol_format, origin_side.to_string(), amount.to_u64().unwrap(), "10".to_string(), "".to_string(), "".to_string()).await;
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
@@ -209,7 +208,7 @@ impl Platform for KucoinSwap {
         }
     }
 
-    async fn cancel_order(&self, order_id: &str, _is_custom_id: Option<bool>) -> Result<Order, Error> {
+    async fn cancel_order(&self, order_id: &str, _is_custom_id: bool) -> Result<Order, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.cancel_order(symbol_array[1].to_string().to_lowercase(), order_id.to_string()).await;
         if res_data.code == "200" {
@@ -227,7 +226,7 @@ impl Platform for KucoinSwap {
     }
 
     // 指令下单
-    async fn command_order(&self, order_command: OrderCommand) {
+    async fn command_order(&self, _order_command: OrderCommand) {
         todo!()
     }
 }

standard/src/lib.rs

@@ -187,7 +187,7 @@ pub struct Ticker {
 /// - `min_notional(Decimal)`: 最小下单金额
 /// - `max_notional(Decimal)`: 最大下单金额
 /// - `ct_val(Decimal)`: 合约价值
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Market {
     pub symbol: String,
     pub base_asset: String,
@@ -336,9 +336,9 @@ pub trait Platform {
     // 交易账户互转
     async fn wallet_transfers(&self, coin: &str, from: &str, to: &str, amount: Decimal) -> Result<String, Error>;
     // 下单接口
-    async fn take_order(&self, custom_id: &str, origin_side: &str, coin: &str, amount: Decimal) -> Result<Order, Error>;
+    async fn take_order(&self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error>;
     // 撤销订单
-    async fn cancel_order(&self, order_id: &str, is_custom_id: Option<bool>) -> Result<Order, Error>;
+    async fn cancel_order(&self, order_id: &str, is_custom_id: bool) -> Result<Order, Error>;
     // 批量撤销订单
     async fn cancel_orders(&self) -> Result<Vec<Order>, Error>;
     // 指令下单

standard/tests/libs_test.rs

@@ -1,5 +1,6 @@
 use std::collections::BTreeMap;
 use std::env;
+use rust_decimal_macros::dec;
 use exchanges::proxy;
 use standard::{Platform, PositionModeEnum};
 use standard::utils;
@@ -169,6 +170,20 @@ async fn test_set_dual_leverage() {
     println!("gate_swap set_dual_leverage:{:?}", gate_swap_exchange.set_dual_leverage("10").await);
 }
 
+// 测试Gate 测试下单
+#[tokio::test]
+async fn test_take_order() {
+    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
+    println!("gate_swap take_order:{:?}", gate_swap_exchange.take_order("123456", "pd", dec!(0.038850), dec!(1)).await);
+}
+
+// 测试Gate 撤销订单
+#[tokio::test]
+async fn test_cancel_order() {
+    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
+    println!("gate_swap cancel_order:{:?}", gate_swap_exchange.cancel_order("337811438982", false).await);
+}
+
 // 测试kucoin 获取持仓信息
 #[tokio::test]
 async fn test_kucoin_swap_get_position() {