as-rust/exchanges/tests/test.rs

use std::{fs, thread};
use exchanges::gate_swap_rest::GateSwapRest;
use std::collections::BTreeMap;
use std::io::{BufRead, BufReader,  Write};
use std::net::{TcpListener, TcpStream};
use std::sync::{mpsc};
use exchanges::binance_usdt_swap_rest::BinanceUsdtSwapRest;
use exchanges::kucoin_swap_rest::KucoinSwapRest;
use exchanges::kuconin_swap_ws::{KuconinSubscribeType, KuconinSwapWs, KuconinWsType};
use exchanges::{proxy};
use exchanges::binance_usdt_swap_ws::BinanceUsdtSwapWs;
use exchanges::okx_swap_ws::{OkxSubscribeType, OkxSwapWs, OkxWsType};


#[tokio::test]
async fn test_import() {
    /*******走代理：根据环境变量配置来决定,如果配置了走代理，没有配置不走*******/
    if proxy::ParsingDetail::http_enable_proxy() {
        println!("检测有代理配置，配置走代理")
    }

    //获取代理
    // demo_get_http_proxy();

    //币安---深度socket-公共频道订阅
    // demo_pub_ws_ba();
    // 币安-rest-获取账户信息
    // demo_rest_ba().await;

    //gate-rest -账户信息
    // demo_rest_gate().await;


    //kucoin_rest -账户信息
    // demo_rest_kucoin().await;


    //Kuconin-ws--公共频道
    // demo_ws_kucoin_pu().await;
    //Kuconin-ws--私有频道
    demo_ws_kucoin_pr().await;

    //okx - Business 频道
    // demo_ws_okx_bu().await;
    //okx - public 频道
    // demo_ws_okx_pu().await;
}

async fn demo_ws_okx_pu() {
    let  btree_map: BTreeMap<String, String> = BTreeMap::new();
    let (tx, rx) = mpsc::channel();
    let mut ku_ws = OkxSwapWs::new(false, btree_map, OkxWsType::Public, tx).await;
    ku_ws.set_subscribe(vec![OkxSubscribeType::PuIndexTickers]);
    thread::spawn(move || {
        ku_ws.custom_subscribe(vec!["BTC-USD".to_string()]);
    });
    let mut stdout = std::io::stdout();
    loop {
        if let Ok(received) = rx.try_recv() {
            writeln!(stdout, "age: {:?}", received).unwrap();
        }
    }
}

async fn demo_ws_okx_bu() {
    let btree_map: BTreeMap<String, String> = BTreeMap::new();
    let (tx, rx) = mpsc::channel();
    let mut ku_ws = OkxSwapWs::new(false, btree_map, OkxWsType::Business, tx).await;
    ku_ws.set_subscribe(vec![OkxSubscribeType::BuIndexCandle30m]);
    thread::spawn(move || {
        ku_ws.custom_subscribe(vec!["BTC-USD".to_string()]);
    });
    let mut stdout = std::io::stdout();
    loop {
        if let Ok(received) = rx.try_recv() {
            writeln!(stdout, "age: {:?}", received).unwrap();
        }
    }
}

async fn demo_ws_kucoin_pr() {
    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
    btree_map.insert("access_key".to_string(), "6393f3565f0d4500011f846b".to_string());
    btree_map.insert("secret_key".to_string(), "9c0df8b7-daaa-493e-a53a-82703067f7dd".to_string());
    btree_map.insert("pass_key".to_string(), "b87d055f".to_string());
    println!("----------------------btree_map{:?}", btree_map.clone());
    let (tx, rx) = mpsc::channel();
    let mut ku_ws = KuconinSwapWs::new(false, btree_map.clone(),
                                       KuconinWsType::Private, tx).await;
    ku_ws.set_subscribe(vec![KuconinSubscribeType::PrContractMarketTradeOrdersSys]);
    thread::spawn(move || {
        ku_ws.custom_subscribe(vec!["ACHUSDTM".to_string(), "ROSEUSDTM".to_string()]);
    });
    let mut stdout = std::io::stdout();
    loop {
        if let Ok(received) = rx.try_recv() {
            writeln!(stdout, "age: {:?}", received).unwrap();
        }
    }
}

async fn demo_ws_kucoin_pu() {
    let  btree_map: BTreeMap<String, String> = BTreeMap::new();
    let (tx, rx) = mpsc::channel();
    let mut ku_ws = KuconinSwapWs::new(false, btree_map, KuconinWsType::Public, tx).await;
    ku_ws.set_subscribe(vec![KuconinSubscribeType::PuContractMarketLevel2Depth50]);
    thread::spawn(move || {
        ku_ws.custom_subscribe(vec!["ACHUSDTM".to_string(), "ROSEUSDTM".to_string()]);
    });
    let mut stdout = std::io::stdout();
    loop {
        if let Ok(received) = rx.try_recv() {
            writeln!(stdout, "age: {:?}", received).unwrap();
        }
    }
}

async fn demo_rest_kucoin() {
    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
    btree_map.insert("access_key".to_string(), "".to_string());
    btree_map.insert("secret_key".to_string(), "".to_string());
    btree_map.insert("pass_key".to_string(), "".to_string());

    let kucoin_exc = KucoinSwapRest::new(false, btree_map);
    let res_data = kucoin_exc.get_server_time().await;
    println!("kucoin_exc-rest - get_server_time- {:?}", res_data);
    // let res_data = kucoin_exc.get_account("USDT".to_string()).await;
    // println!("kucoin_exc-rest - get_account- {:?}", res_data);
    // let res_data = kucoin_exc.get_position("XBTUSDM".to_string()).await;
    // println!("kucoin_exc-rest - get_position- {:?}", res_data);
    // let res_data = kucoin_exc.get_market_details().await;
    // println!("kucoin_exc-rest - get_market_details- {:?}", res_data);
    // let res_data = kucoin_exc.get_ticker("ROSEUSDTM".to_string()).await;
    // println!("kucoin_exc-rest - get_ticker- {:?}", res_data);
    // let res_data = kucoin_exc.get_orders("active".to_string(), "ROSEUSDTM".to_string()).await;
    // println!("kucoin_exc-rest - get_orders- {:?}", res_data);
    // let res_data = kucoin_exc.get_positions("USDT".to_string()).await;
    // println!("kucoin_exc-rest - get_positions- {:?}", res_data);
    // let res_data = kucoin_exc.get_orders_details("111".to_string(), "".to_string()).await;
    // println!("kucoin_exc-rest - get_orders_details- {:?}", res_data);
    // let res_data = kucoin_exc.swap_bazaar_order(
    //     "cs_202309111808".to_string(),
    //     "ROSEUSDTM".to_string(),
    //     "pd".to_string(),
    //     1,
    //     "10".to_string(),
    //     "0.03856".to_string(),
    //     "limit".to_string(),
    // ).await;
    // println!("kucoin_exc-rest - swap_bazaar_order- {:?}
    // let res_data = kucoin_exc.cancel_order("12312".to_string(), "".to_string()).await;
    // println!("kucoin_exc-rest - cancel_order- {:?}", res_data);

    // let res_data = kucoin_exc.get_public_token().await;
    // println!("kucoin_exc-rest - get_public_token- {:?}", res_data);
}

async fn demo_rest_gate() {
    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
    btree_map.insert("access_key".to_string(), "".to_string());
    btree_map.insert("secret_key".to_string(), "".to_string());

    let gate_exc = GateSwapRest::new(false, btree_map);
    let res_data = gate_exc.get_account("usdt".to_string()).await;
    println!("gate-rest -账户信息{:?}", res_data);
    // let res_data = gate_exc.get_position("usdt".to_string(), "CYBER_USDT".to_string()).await;
    // println!("gate-rest -持仓信息{:?}", res_data);
    // let res_data = gate_exc.get_ticker("usdt".to_string()).await;
    // println!("gate-rest -ticker{:?}", res_data);
    // let res_data = gate_exc.get_server_time().await;
    // println!("gate-rest -get_server_time{:?}", res_data);
    // let res_data = gate_exc.get_user_position("usdt".to_string()).await;
    // println!("gate-rest -get_server_time{:?}", res_data);
    // let res_data = gate_exc.get_order_details("usdt".to_string(), "11335522".to_string()).await;
    // println!("gate-rest -get_order_details{:?}", res_data);
    // let res_data = gate_exc.get_orders("usdt".to_string(), "open".to_string()).await;
    // println!("gate-rest -get_orders{:?}", res_data);
    // let params = serde_json::json!({
    //         "contract":"CYBER_USDT",
    //         "size":-1,
    //         "price":"0",
    //         "tif":"ioc",
    //      });
    // let res_data = gate_exc.take_order("usdt".to_string(), params).await;
    // println!("gate-rest -get_orders{:?}", res_data);
    // let res_data = gate_exc.setting_dual_mode("usdt".to_string(), true).await;
    // println!("gate-rest -setting_dual_mode{:?}", res_data);
    // let res_data = gate_exc.setting_dual_leverage("usdt".to_string(),
    //                                               "CYBER_USDT".to_string(),
    //                                               "20".to_string(),
    // ).await;
    // println!("gate-rest -setting_dual_mode{:?}", res_data);
    // let res_data = gate_exc.wallet_transfers("usdt".to_string(),
    //                                               "CYBER_USDT".to_string(),
    //                                               "20".to_string(),
    // ).await;
    // println!("gate-rest -setting_dual_mode{:?}", res_data);
    // let res_data = gate_exc.cancel_order("usdt".to_string(),
    //                                      "12345".to_string(),
    // ).await;
    // println!("gate-rest -setting_dual_mode{:?}", res_data);
    // let res_data = gate_exc.cancel_orders("usdt".to_string(),
    //                                      "CYBER_USDT".to_string(),
    // ).await;
    // println!("gate-rest -cancel_orders{:?}", res_data);
    // let res_data = gate_exc.order(
    //     "usdt".to_string(),
    //     "long".to_string(),
    //     "buy".to_string(),
    //     "ROSE_USDT".to_string(),
    //     1,
    //     "0.03888".to_string(),
    //     "t-my-custom-id-001".to_string(),
    // ).await;
    // println!("gate-rest -order{:?}", res_data);
}

async fn demo_rest_ba() {
    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
    btree_map.insert("access_key".to_string(), "".to_string());
    btree_map.insert("secret_key".to_string(), "".to_string());

    let ba_exc = BinanceUsdtSwapRest::new(false, btree_map);
    let res_data = ba_exc.get_account().await;
    println!("币安-rest-获取账户信息{:?}", res_data);
}

fn demo_pub_ws_ba() {
    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
    btree_map.insert("lable".parse().unwrap(), "binance".parse().unwrap());//交易行名称
    let (tx, rx) = mpsc::channel();
    thread::spawn(move || {
        let ba_exc = BinanceUsdtSwapWs::new(false, btree_map, tx);
        ba_exc.custom_subscribe(vec![&"BTCUSDT", "ROSEUSDT"], 1, 0);
    });

    let mut stdout = std::io::stdout();
    loop {
        if let Ok(received) = rx.try_recv() {
            writeln!(stdout, "age: {:?}", received).unwrap();
        }
    }
}

fn demo_get_http_proxy() {
    //代理地址
    let parsing_detail = proxy::ParsingDetail::parsing_environment_variables();
    println!("----代理信息：{:?}", parsing_detail);
}


/*********************web服务*/
fn demo_http() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
    for stream in listener.incoming() {
        let stream = stream.unwrap();

        handle_connection(stream);
    }
}


fn handle_connection(mut stream: TcpStream) {
    let buf_reader = BufReader::new(&mut stream);
    let http_request: Vec<_> = buf_reader
        .lines()
        .map(|result| result.unwrap())
        .take_while(|line| !line.is_empty())
        .collect();
    println!("Request: {:#?}", http_request);
    println!("Request2: {:#?}", http_request[0]);
    println!("Request3: {:#?}", http_request[1]);

    let (status_line, filename) = if http_request[0] == "GET / HTTP/1.1" {
        ("HTTP/1.1 200 OK", "hello.html")
    } else {
        ("HTTP/1.1 404 NOT FOUND", "404.html")
    };

    let status_line = "HTTP/1.1 200 OK";
    let contents = fs::read_to_string("src/404.html").unwrap();
    let length = contents.len();

    let response =
        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
    // let response = "HTTP/1.1 200 OK\r\n\r\nccccc";

    stream.write_all(response.as_bytes()).unwrap();
}