as-rust/standard/tests/exchange_test.rs

use std::collections::{BTreeMap};
use std::{env};
use std::io::Error;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::time::Duration;
use rust_decimal_macros::dec;
use tokio::sync::mpsc::{channel, Receiver, Sender};
use tokio::try_join;
use tracing::{error, trace};
// use exchanges::bitget_spot_ws::{BitgetSpotWs, BitgetSubscribeType, BitgetWsType};
use exchanges::kucoin_spot_ws::{KucoinSpotWs, KucoinSubscribeType, KucoinWsType};
// use exchanges::binance_spot_ws::{BinanceSpotSubscribeType, BinanceSpotWs, BinanceSpotWsType};
// use exchanges::okx_swap_ws::{OkxSubscribeType, OkxSwapWs, OkxWsType};
// use exchanges::kucoin_swap_ws::{KucoinSubscribeType, KucoinSwapWs, KucoinWsType};
use exchanges::response_base::ResponseData;
use standard::exchange::{Exchange, ExchangeEnum};
// use standard::{binance_handle, Order, Platform, utils};
// use standard::{okx_handle, Order, Platform, utils};
// use standard::{kucoin_handle, Order, Platform, utils};
use standard::{kucoin_spot_handle, Order, Platform, utils};
// use standard::{bitget_spot_handle, Order, Platform, utils};

// 创建实体
#[allow(dead_code)]
pub async fn test_new_exchange(exchange: ExchangeEnum, symbol: &str) -> Box<dyn Platform> {
    utils::proxy_handle();
    let (order_sender, _order_receiver): (Sender<Order>, Receiver<Order>) = channel(1024);
    let (error_sender, _error_receiver): (Sender<Error>, Receiver<Error>) = channel(1024);
    match exchange {
        ExchangeEnum::BinanceSwap => {
            let mut params: BTreeMap<String, String> = BTreeMap::new();
            let access_key = env::var("binance_access_key").unwrap_or("".to_string());
            let secret_key = env::var("binance_secret_key").unwrap_or("".to_string());
            params.insert("access_key".to_string(), access_key);
            params.insert("secret_key".to_string(), secret_key);
            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
        }
        ExchangeEnum::BinanceSpot => {
            let mut params: BTreeMap<String, String> = BTreeMap::new();
            let access_key = env::var("binance_access_key").unwrap_or("".to_string());
            let secret_key = env::var("binance_secret_key").unwrap_or("".to_string());
            params.insert("access_key".to_string(), access_key);
            params.insert("secret_key".to_string(), secret_key);
            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
        }
        ExchangeEnum::GateSwap => {
            let mut params: BTreeMap<String, String> = BTreeMap::new();
            let access_key = env::var("gate_access_key").unwrap_or("".to_string());
            let secret_key = env::var("gate_secret_key").unwrap_or("".to_string());
            params.insert("access_key".to_string(), access_key);
            params.insert("secret_key".to_string(), secret_key);
            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
        }
        ExchangeEnum::GateSpot => {
            let mut params: BTreeMap<String, String> = BTreeMap::new();
            let access_key = env::var("gate_access_key").unwrap_or("".to_string());
            let secret_key = env::var("gate_secret_key").unwrap_or("".to_string());
            params.insert("access_key".to_string(), access_key);
            params.insert("secret_key".to_string(), secret_key);
            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
        }
        ExchangeEnum::KucoinSwap => {
            let mut params: BTreeMap<String, String> = BTreeMap::new();
            let access_key = env::var("kucoin_access_key").unwrap_or("".to_string());
            let secret_key = env::var("kucoin_secret_key").unwrap_or("".to_string());
            let pass_key = env::var("kucoin_pass_key").unwrap_or("".to_string());
            params.insert("access_key".to_string(), access_key);
            params.insert("secret_key".to_string(), secret_key);
            params.insert("pass_key".to_string(), pass_key);
            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
        }
        ExchangeEnum::KucoinSpot => {
            let mut params: BTreeMap<String, String> = BTreeMap::new();
            let access_key = env::var("kucoin_access_key").unwrap_or("".to_string());
            let secret_key = env::var("kucoin_secret_key").unwrap_or("".to_string());
            let pass_key = env::var("kucoin_pass_key").unwrap_or("".to_string());
            params.insert("access_key".to_string(), access_key);
            params.insert("secret_key".to_string(), secret_key);
            params.insert("pass_key".to_string(), pass_key);
            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
        }
        ExchangeEnum::OkxSwap => {
            let mut params: BTreeMap<String, String> = BTreeMap::new();
            let access_key = env::var("okx_access_key").unwrap_or("".to_string());
            let secret_key = env::var("okx_secret_key").unwrap_or("".to_string());
            let pass_key = env::var("okx_passphrase").unwrap_or("".to_string());
            params.insert("access_key".to_string(), access_key);
            params.insert("secret_key".to_string(), secret_key);
            params.insert("pass_key".to_string(), pass_key);
            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
        }
        ExchangeEnum::BitgetSpot => {
            let mut params: BTreeMap<String, String> = BTreeMap::new();
            let access_key = env::var("bitget_access_key").unwrap_or("".to_string());
            let secret_key = env::var("bitget_secret_key").unwrap_or("".to_string());
            let pass_key = env::var("bitget_pass_key").unwrap_or("".to_string());
            params.insert("access_key".to_string(), access_key);
            params.insert("secret_key".to_string(), secret_key);
            params.insert("pass_key".to_string(), pass_key);
            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
        }
    }
}

#[allow(dead_code)]
pub async fn test_new_exchange_wss<T>(exchange: ExchangeEnum, symbol: &str, subscriber_type: T, mold: &str) where Vec<KucoinSubscribeType>: From<T> {
    utils::proxy_handle();

    match exchange {
        ExchangeEnum::BinanceSpot => {
            // let symbol_format = utils::format_symbol(symbol.to_string(), "").to_uppercase();
            // trace!(symbol_format);
            // let name = format!("binance_usdt_swap@{}", symbol.to_string().to_lowercase());
            // let bool_v1 = Arc::new(AtomicBool::new(true));
            //
            // let (res_sender, mut res_receiver): (Sender<ResponseData>, Receiver<ResponseData>) = channel(1024);
            // let mut params: BTreeMap<String, String> = BTreeMap::new();
            // let access_key = env::var("binance_access_key").unwrap_or("".to_string());
            // let secret_key = env::var("binance_secret_key").unwrap_or("".to_string());
            // params.insert("access_key".to_string(), access_key);
            // params.insert("secret_key".to_string(), secret_key);
            // let mut exchange_wss;
            // exchange_wss = BinanceSpotWs::new_label(name, false, params, BinanceSpotWsType::PublicAndPrivate, res_sender);
            // exchange_wss.set_subscribe(subscriber_type.into());
            //
            // let t1 = tokio::spawn(async move {
            //     exchange_wss.custom_subscribe(bool_v1, vec![symbol_format]).await;
            // });
            // let mold_arc = Arc::new(mold.to_string());
            // let t2 = tokio::spawn(async move {
            //     let mold_clone = Arc::clone(&mold_arc);
            //     loop {
            //         tokio::time::sleep(Duration::from_millis(1)).await;
            //         if let Ok(received) = res_receiver.try_recv() {
            //             match mold_clone.as_str() {
            //                 "depth" => {
            //                     if received.data != "" {
            //                         let result = binance_handle::handle_special_depth(received);
            //                         trace!(?result)
            //                     }
            //                 }
            //                 "ticker" => {
            //                     if received.data != "" {
            //                         let result = binance_handle::handle_special_ticker(received);
            //                         trace!(?result)
            //                     }
            //                 }
            //                 _ => {
            //                     error!("没有该命令！mode={}", mold_clone);
            //                     panic!("没有该命令！mode={}", mold_clone)
            //                 }
            //             }
            //         }
            //     }
            // });
            // try_join!(t1, t2).unwrap();
            error!("该交易所不支持！test_new_exchange_wss：{:?}",exchange);
            panic!("该交易所不支持！test_new_exchange_wss：{:?}", exchange)
        }
        ExchangeEnum::BinanceSwap => {
            error!("该交易所不支持！test_new_exchange_wss：{:?}",exchange);
            panic!("该交易所不支持！test_new_exchange_wss：{:?}", exchange)
        }
        ExchangeEnum::GateSwap => {
            error!("该交易所不支持！test_new_exchange_wss：{:?}",exchange);
            panic!("该交易所不支持！test_new_exchange_wss：{:?}", exchange)
        }
        ExchangeEnum::KucoinSwap => {
            // let symbol_format = format!("{}M", utils::format_symbol(symbol.to_string(), ""));
            // let symbol_back = utils::format_symbol(symbol.to_string(), "_");
            // let name = format!("kucoin_usdt_swap@{}", symbol.to_string().to_lowercase());
            // let bool_v1 = Arc::new(AtomicBool::new(true));
            //
            // let (res_sender, mut res_receiver): (Sender<ResponseData>, Receiver<ResponseData>) = channel(1024);
            // let mut params: BTreeMap<String, String> = BTreeMap::new();
            // let access_key = env::var("kucoin_access_key").unwrap_or("".to_string());
            // let secret_key = env::var("kucoin_secret_key").unwrap_or("".to_string());
            // let pass_key = env::var("kucoin_pass_key").unwrap_or("".to_string());
            // params.insert("access_key".to_string(), access_key);
            // params.insert("secret_key".to_string(), secret_key);
            // params.insert("pass_key".to_string(), pass_key);
            // let mut exchange_wss;
            // if ["depth", "ticker"].contains(&mold) {
            //     exchange_wss = KucoinSwapWs::new_label(name, false, params, KucoinWsType::Public, res_sender).await
            // } else {
            //     exchange_wss = KucoinSwapWs::new_label(name, false, params, KucoinWsType::Private, res_sender).await
            // }
            // exchange_wss.set_subscribe(subscriber_type.into());
            //
            // let t1 = tokio::spawn(async move {
            //     exchange_wss.custom_subscribe(bool_v1, vec![symbol_format]).await;
            // });
            // let mold_arc = Arc::new(mold.to_string());
            // let t2 = tokio::spawn(async move {
            //     let mold_clone = Arc::clone(&mold_arc);
            //     loop {
            //         tokio::time::sleep(Duration::from_millis(1)).await;
            //         if let Ok(received) = res_receiver.try_recv() {
            //             match mold_clone.as_str() {
            //                 "depth" => {
            //                     let result = kucoin_handle::handle_special_depth(received);
            //                     trace!(?result)
            //                 }
            //                 "ticker" => {
            //                     let result = kucoin_handle::handle_special_ticker(received);
            //                     trace!(?result)
            //                 }
            //                 "account" => {
            //                     trace!(?received);
            //                     let result = kucoin_handle::handle_account_info(received, symbol_back.clone());
            //                     trace!(?result)
            //                 }
            //                 "position" => {
            //                     trace!(?received);
            //                     let result = kucoin_handle::handle_position(received, dec!(1));
            //                     trace!(?result)
            //                 }
            //                 "orders" => {
            //                     trace!(?received);
            //                     let result = kucoin_handle::handle_order(received, dec!(0.001));
            //                     trace!(?result)
            //                 }
            //                 _ => {
            //                     error!("没有该命令！mode={}", mold_clone);
            //                     panic!("没有该命令！mode={}", mold_clone)
            //                 }
            //             }
            //         }
            //     }
            // });
            // try_join!(t1, t2).unwrap();
        }
        ExchangeEnum::KucoinSpot => {
            let symbol_format = utils::format_symbol(symbol.to_string(), "-").to_uppercase();
            let symbol_back = utils::format_symbol(symbol.to_string(), "_");
            trace!(symbol_format);
            let name = format!("kucoin_usdt_spot@{}", symbol.to_string().to_lowercase());
            let bool_v1 = Arc::new(AtomicBool::new(true));

            let (res_sender, mut res_receiver): (Sender<ResponseData>, Receiver<ResponseData>) = channel(1024);
            let mut params: BTreeMap<String, String> = BTreeMap::new();
            let access_key = env::var("kucoin_access_key").unwrap_or("".to_string());
            let secret_key = env::var("kucoin_secret_key").unwrap_or("".to_string());
            let pass_key = env::var("kucoin_pass_key").unwrap_or("".to_string());
            params.insert("access_key".to_string(), access_key);
            params.insert("secret_key".to_string(), secret_key);
            params.insert("pass_key".to_string(), pass_key);

            let mut exchange_wss = if ["depth", "ticker"].contains(&mold) {
                KucoinSpotWs::new_label(name, false, params, KucoinWsType::Public, res_sender).await
            } else {
                KucoinSpotWs::new_label(name, false, params, KucoinWsType::Private, res_sender).await
            };

            exchange_wss.set_subscribe(subscriber_type.into());

            let t1 = tokio::spawn(async move {
                exchange_wss.custom_subscribe(bool_v1, vec![symbol_format]).await;
            });
            let mold_arc = Arc::new(mold.to_string());
            let t2 = tokio::spawn(async move {
                let mold_clone = Arc::clone(&mold_arc);
                loop {
                    tokio::time::sleep(Duration::from_millis(1)).await;
                    if let Ok(received) = res_receiver.try_recv() {
                        trace!(?received);
                        match mold_clone.as_str() {
                            "depth" => {
                                if received.data != "" {
                                    let result = kucoin_spot_handle::handle_special_depth(received);
                                    trace!(?result)
                                }
                            }
                            "ticker" => {
                                if received.data != "" {
                                    let result = kucoin_spot_handle::handle_special_ticker(received);
                                    trace!(?result)
                                }
                            }
                            "account" => {
                                if received.data != "" {
                                    let result = kucoin_spot_handle::handle_account_info(received, symbol_back.clone());
                                    trace!(?result)
                                }
                            }
                            "orders" => {
                                if received.data != "" {
                                    let result = kucoin_spot_handle::handle_order(received, dec!(1));
                                    trace!(?result)
                                }
                            }
                            _ => {
                                error!("没有该命令！mode={}", mold_clone);
                                panic!("没有该命令！mode={}", mold_clone)
                            }
                        }
                    }
                }
            });
            try_join!(t1, t2).unwrap();
        }
        ExchangeEnum::BitgetSpot => {
            // let symbol_format = utils::format_symbol(symbol.to_string(), "-").to_uppercase();
            // let symbol_back = utils::format_symbol(symbol.to_string(), "_");
            // trace!(symbol_format);
            // let name = format!("bitget_usdt_spot@{}", symbol.to_string().to_lowercase());
            // let bool_v1 = Arc::new(AtomicBool::new(true));
            //
            // let (res_sender, mut res_receiver): (Sender<ResponseData>, Receiver<ResponseData>) = channel(1024);
            // let mut params: BTreeMap<String, String> = BTreeMap::new();
            // let access_key = env::var("bitget_access_key").unwrap_or("".to_string());
            // let secret_key = env::var("bitget_secret_key").unwrap_or("".to_string());
            // let pass_key = env::var("bitget_pass_key").unwrap_or("".to_string());
            // params.insert("access_key".to_string(), access_key);
            // params.insert("secret_key".to_string(), secret_key);
            // params.insert("pass_key".to_string(), pass_key);
            //
            // let mut exchange_wss = if ["depth", "ticker"].contains(&mold) {
            //     BitgetSpotWs::new_label(name, false, params, BitgetWsType::Public, res_sender)
            // } else {
            //     BitgetSpotWs::new_label(name, false, params, BitgetWsType::Private, res_sender)
            // };
            //
            // exchange_wss.set_subscribe(subscriber_type.into());
            //
            // let t1 = tokio::spawn(async move {
            //     exchange_wss.custom_subscribe(bool_v1, vec![symbol_format]).await;
            // });
            // let mold_arc = Arc::new(mold.to_string());
            // let t2 = tokio::spawn(async move {
            //     let mold_clone = Arc::clone(&mold_arc);
            //     loop {
            //         tokio::time::sleep(Duration::from_millis(1)).await;
            //         if let Ok(received) = res_receiver.try_recv() {
            //             match mold_clone.as_str() {
            //                 "depth" => {
            //                     if received.data != "" {
            //                         let result = bitget_spot_handle::handle_special_depth(received);
            //                         trace!(?result)
            //                     }
            //                 }
            //                 "ticker" => {
            //                     if received.data != "" {
            //                         let result = bitget_spot_handle::handle_special_ticker(received);
            //                         trace!(?result)
            //                     }
            //                 }
            //                 "account" => {
            //                     if received.data != "" {
            //                         let result = bitget_spot_handle::handle_account_info(received, symbol_back.clone());
            //                         trace!(?result)
            //                     }
            //                 }
            //                 "orders" => {
            //                     if received.data != "" {
            //                         let result = bitget_spot_handle::handle_order(received, dec!(1));
            //                         trace!(?result)
            //                     }
            //                 }
            //                 _ => {
            //                     error!("没有该命令！mode={}", mold_clone);
            //                     panic!("没有该命令！mode={}", mold_clone)
            //                 }
            //             }
            //         }
            //     }
            // });
            // try_join!(t1, t2).unwrap();
        }
        ExchangeEnum::OkxSwap => {
            // let symbol_format = utils::format_symbol(symbol.to_string(), "-").to_uppercase();
            // let symbol_back = utils::format_symbol(symbol.to_string(), "_");
            // trace!(symbol_format);
            // let name = format!("okx_usdt_swap@{}", symbol.to_string().to_lowercase());
            // let bool_v1 = Arc::new(AtomicBool::new(true));
            //
            // let (res_sender, mut res_receiver): (Sender<ResponseData>, Receiver<ResponseData>) = channel(1024);
            // let mut params: BTreeMap<String, String> = BTreeMap::new();
            // let access_key = env::var("okx_access_key").unwrap_or("".to_string());
            // let secret_key = env::var("okx_secret_key").unwrap_or("".to_string());
            // let passphrase = env::var("okx_passphrase").unwrap_or("".to_string());
            // params.insert("access_key".to_string(), access_key);
            // params.insert("secret_key".to_string(), secret_key);
            // params.insert("pass_key".to_string(), passphrase);
            //
            // let mut exchange_wss = if ["depth", "ticker"].contains(&mold) {
            //     OkxSwapWs::new_label(name, false, params, OkxWsType::Public, res_sender)
            // } else if ["account", "orders", "position"].contains(&mold) {
            //     OkxSwapWs::new_label(name, false, params, OkxWsType::Private, res_sender)
            // } else {
            //     OkxSwapWs::new_label(name, false, params, OkxWsType::Business, res_sender)
            // };
            //
            // exchange_wss.set_subscribe(subscriber_type.into());
            //
            // let t1 = tokio::spawn(async move {
            //     exchange_wss.custom_subscribe(bool_v1, vec![symbol_format]).await;
            // });
            // let mold_arc = Arc::new(mold.to_string());
            // let t2 = tokio::spawn(async move {
            //     let mold_clone = Arc::clone(&mold_arc);
            //     loop {
            //         tokio::time::sleep(Duration::from_millis(1)).await;
            //         if let Ok(received) = res_receiver.try_recv() {
            //             match mold_clone.as_str() {
            //                 "depth" => {
            //                     if received.data != "" {
            //                         let result = okx_handle::handle_special_depth(received);
            //                         trace!(?result)
            //                     }
            //                 }
            //                 "ticker" => {
            //                     if received.data != "" {
            //                         let result = okx_handle::handle_special_ticker(received);
            //                         trace!(?result)
            //                     }
            //                 }
            //                 "account" => {
            //                     if received.data != "" {
            //                         let result = okx_handle::handle_account_info(received, symbol_back.clone());
            //                         trace!(?result)
            //                     }
            //                 }
            //                 "position" => {
            //                     if received.data != "" {
            //                         let result = okx_handle::handle_position(received, dec!(10));
            //                         trace!(?result)
            //                     }
            //                 }
            //                 "orders" => {
            //                     if received.data != "" {
            //                         let result = okx_handle::handle_order(received, dec!(10));
            //                         trace!(?result)
            //                     }
            //                 }
            //                 _ => {
            //                     error!("没有该命令！mode={}", mold_clone);
            //                     panic!("没有该命令！mode={}", mold_clone)
            //                 }
            //             }
            //         }
            //     }
            // });
            // try_join!(t1, t2).unwrap();
        }
        _ => {
            error!("该交易所不支持！test_new_exchange_wss：{:?}",exchange);
            panic!("该交易所不支持！test_new_exchange_wss：{:?}", exchange)
        }
    }
}