ticker_viewer/src/binance_swap/binance_swap_standard.rs

use std::io::{Error, ErrorKind};
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use crate::binance_swap::binance_swap_rest::{get_agg_trades, get_trades};
use crate::struct_standard::{AggTrades, Trades};
use crate::utils::utils::format_symbol;

#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
struct SwapTrades {
    id: i64,
    price: String,
    qty: Decimal,
    quote_qty: String,
    time: i64,
    is_buyer_maker: bool,
}

#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
struct SwapAggTrades {
    a: i64,
    p: String,
    q: Decimal,
    f: i64,
    l: i64,
    #[serde(rename = "T")]
    t: i64,
    m: bool,

}

pub(crate) async fn standard_agg_trades(symbol: &str, start_at: &str, end_at: &str, trade_id: &str) -> Result<Vec<AggTrades>, Error> {
    let symbol_fmt = format_symbol(symbol, "");

    let start_at_milli = if start_at != "" { format!("{}{}", start_at, "000") } else { "".to_string() };
    let end_at_milli = if end_at != "" { format!("{}{}", end_at, "000") } else { "".to_string() };
    let res_data = get_agg_trades(&symbol_fmt, &start_at_milli, &end_at_milli, trade_id).await;
    if res_data.code == "200" {
        let res_data_str = res_data.data;
        let trades_list: Vec<SwapAggTrades> = serde_json::from_str(&res_data_str).unwrap();
        let result = trades_list.iter().map(|item| {
            AggTrades {
                id: item.a.to_string(),
                start_id: item.f.to_string(),
                end_id: item.l.to_string(),
                symbol: symbol.to_string(),
                create_time: item.t.to_string(),
                size: if item.m { format!("-{}", item.q.to_string()) } else { item.q.to_string() },
                price: item.p.clone(),
            }
        }).collect();
        Ok(result)
    } else {
        Err(Error::new(ErrorKind::Other, res_data.to_string()))
    }
}

#[allow(dead_code)]
pub async fn standard_trades(symbol: &str, limit: &str, trade_id: &str) -> Result<Vec<Trades>, Error> {
    let symbol_fmt = format_symbol(symbol, "");
    let res_data = get_trades(&symbol_fmt, limit, trade_id).await;
    if res_data.code == "200" {
        let res_data_str = res_data.data;
        let trades_list: Vec<SwapTrades> = serde_json::from_str(&res_data_str).unwrap();
        let result = trades_list.iter().map(|item| {
            Trades {
                id: item.id.to_string(),
                data_type: "ticker_binance".to_string(),
                symbol: symbol.to_string(),
                create_time: item.time.to_string(),
                size: if item.is_buyer_maker { item.qty.to_string() } else { format!("-{}", item.qty.to_string()) },
                price: item.price.clone(),
                side: if item.is_buyer_maker { "BUY".to_string() } else { "SELL".to_string() },
                is_effect: true,
            }
        }).collect();
        Ok(result)
    } else {
        Err(Error::new(ErrorKind::Other, res_data.to_string()))
    }
}