as-rust/standard/src/coinsph_swap.rs

// use std::collections::{BTreeMap};
// use std::io::{Error, ErrorKind};
// use std::str::FromStr;
// use tokio::sync::mpsc::Sender;
// use async_trait::async_trait;
// use rust_decimal::{Decimal};
// use serde_json::{json, Value};
// use tracing::{error, info};
// use crate::{Platform, ExchangeEnum, Account, Position, Ticker, Market, Order, utils};
// use exchanges::coinsph_swap_rest::CoinsphSwapRest;
// use rust_decimal::prelude::FromPrimitive;
//
// #[allow(dead_code)]
// #[derive(Clone)]
// pub struct CoinsphSwap {
//     exchange: ExchangeEnum,
//     symbol: String,
//     is_colo: bool,
//     params: BTreeMap<String, String>,
//     request: CoinsphSwapRest,
//     market: Market,
//     order_sender: Sender<Order>,
//     error_sender: Sender<Error>,
// }
//
// impl CoinsphSwap {
//     pub async fn new(symbol: String, is_colo: bool, params: BTreeMap<String, String>, order_sender: Sender<Order>, error_sender: Sender<Error>) -> CoinsphSwap {
//         let market = Market::new();
//         let mut coinsph_swap = CoinsphSwap {
//             exchange: ExchangeEnum::CoinsphSwap,
//             symbol: symbol.to_uppercase(),
//             is_colo,
//             params: params.clone(),
//             request: CoinsphSwapRest::new(is_colo, params.clone()),
//             market,
//             order_sender,
//             error_sender,
//         };
//
//         // 修改持仓模式
//         let symbol_array: Vec<&str> = symbol.split("_").collect();
//         let mode_result = coinsph_swap.set_dual_mode(symbol_array[1], true).await;
//         match mode_result {
//             Ok(ok) => {
//                 info!("Coinsph:设置持仓模式成功！{:?}", ok);
//             }
//             Err(error) => {
//                 error!("Coinsph:设置持仓模式失败！mode_result={}", error)
//             }
//         }
//         // 获取市场信息
//         coinsph_swap.market = CoinsphSwap::get_market(&mut coinsph_swap).await.unwrap_or(coinsph_swap.market);
//         return coinsph_swap;
//     }
// }
//
// #[async_trait]
// impl Platform for CoinsphSwap {
//     // 克隆方法
//     fn clone_box(&self) -> Box<dyn Platform + Send + Sync> { Box::new(self.clone()) }
//     // 获取交易所模式
//     fn get_self_exchange(&self) -> ExchangeEnum {
//         ExchangeEnum::CoinsphSwap
//     }
//     // 获取交易对
//     fn get_self_symbol(&self) -> String { self.symbol.clone() }
//     // 获取是否使用高速通道
//     fn get_self_is_colo(&self) -> bool {
//         self.is_colo
//     }
//     // 获取params信息
//     fn get_self_params(&self) -> BTreeMap<String, String> {
//         self.params.clone()
//     }
//     // 获取market信息
//     fn get_self_market(&self) -> Market { self.market.clone() }
//     // 获取请求时间
//     fn get_request_delays(&self) -> Vec<i64> { self.request.get_delays() }
//     // 获取请求平均时间
//     fn get_request_avg_delay(&self) -> Decimal { self.request.get_avg_delay() }
//     // 获取请求最大时间
//     fn get_request_max_delay(&self) -> i64 { self.request.get_max_delay() }
//
//     // 获取服务器时间
//     async fn get_server_time(&mut self) -> Result<String, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//     // 获取账号信息
//     async fn get_account(&mut self) -> Result<Account, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     async fn get_spot_account(&mut self) -> Result<Vec<Account>, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     // 获取持仓信息
//     async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//     // 获取所有持仓
//     async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//     // 获取市场行情
//     async fn get_ticker(&mut self) -> Result<Ticker, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     async fn get_ticker_symbol(&mut self, _symbol: String) -> Result<Ticker, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     async fn get_market(&mut self) -> Result<Market, Error> {
//         let symbol_format = utils::format_symbol(self.symbol.clone(), "");
//         let params = json!({});
//         let res_data = self.request.get_market(params).await;
//         if res_data.code == 200 {
//             let symbols = res_data.data["symbols"].as_array().unwrap();
//             let market_info = symbols.iter().find(|&item| item["symbol"].as_str().unwrap() == symbol_format);
//             match market_info {
//                 None => {
//                     error!("coinsph_swap：获取Market信息错误!\nget_market:res_data={:?}", res_data);
//                     Err(Error::new(ErrorKind::Other, res_data.to_string()))
//                 }
//                 Some(value) => {
//                     let base_asset = value["baseAsset"].as_str().unwrap().to_string();
//                     let quote_asset = value["quoteAsset"].as_str().unwrap().to_string();
//
//                     let filter_array = value["filters"].as_array().unwrap().clone();
//                     let price_filter = filter_array.iter().find(|&item| item["filterType"].as_str().unwrap() == "PRICE_FILTER").unwrap();
//                     let lot_size_filter = filter_array.iter().find(|&item| item["filterType"].as_str().unwrap() == "LOT_SIZE").unwrap();
//
//                     let result = Market {
//                         symbol: format!("{}_{}", base_asset, quote_asset),
//                         base_asset,
//                         quote_asset,
//                         tick_size: Decimal::from_str(&price_filter["tickSize"].as_str().unwrap()).unwrap(),
//                         amount_size: Decimal::from_str(lot_size_filter["stepSize"].as_str().unwrap()).unwrap(),
//                         price_precision: Decimal::from_f64(value["pricePrecision"].as_f64().unwrap()).unwrap(),
//                         amount_precision: Decimal::from_f64(value["quantityPrecision"].as_f64().unwrap()).unwrap(),
//                         min_qty: Decimal::from_str(lot_size_filter["minQty"].as_str().unwrap()).unwrap(),
//                         max_qty: Decimal::from_str(lot_size_filter["maxQty"].as_str().unwrap()).unwrap(),
//                         min_notional: Decimal::from_str(price_filter["minPrice"].as_str().unwrap()).unwrap(),
//                         max_notional: Decimal::from_str(price_filter["maxPrice"].as_str().unwrap()).unwrap(),
//                         ct_val: Decimal::ONE,
//                     };
//                     Ok(result)
//                 }
//             }
//         } else {
//             Err(Error::new(ErrorKind::Other, res_data.to_string()))
//         }
//     }
//
//     async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
//         let symbol_format = utils::format_symbol(symbol.clone(), "");
//         let params = json!({});
//         let res_data = self.request.get_market(params).await;
//         if res_data.code == 200 {
//             let symbols = res_data.data["symbols"].as_array().unwrap();
//             let market_info = symbols.iter().find(|&item| item["symbol"].as_str().unwrap() == symbol_format);
//             match market_info {
//                 None => {
//                     error!("coinsph_swap：获取Market信息错误!\nget_market:res_data={:?}", res_data);
//                     Err(Error::new(ErrorKind::Other, res_data.to_string()))
//                 }
//                 Some(value) => {
//                     let base_asset = value["baseAsset"].as_str().unwrap().to_string();
//                     let quote_asset = value["quoteAsset"].as_str().unwrap().to_string();
//
//                     let filter_array = value["filters"].as_array().unwrap().clone();
//                     let price_filter = filter_array.iter().find(|&item| item["filterType"].as_str().unwrap() == "PRICE_FILTER").unwrap();
//                     let lot_size_filter = filter_array.iter().find(|&item| item["filterType"].as_str().unwrap() == "LOT_SIZE").unwrap();
//
//                     let result = Market {
//                         symbol: format!("{}_{}", base_asset, quote_asset),
//                         base_asset,
//                         quote_asset,
//                         tick_size: Decimal::from_str(&price_filter["tickSize"].as_str().unwrap()).unwrap(),
//                         amount_size: Decimal::from_str(lot_size_filter["stepSize"].as_str().unwrap()).unwrap(),
//                         price_precision: Decimal::from_f64(value["pricePrecision"].as_f64().unwrap()).unwrap(),
//                         amount_precision: Decimal::from_f64(value["quantityPrecision"].as_f64().unwrap()).unwrap(),
//                         min_qty: Decimal::from_str(lot_size_filter["minQty"].as_str().unwrap()).unwrap(),
//                         max_qty: Decimal::from_str(lot_size_filter["maxQty"].as_str().unwrap()).unwrap(),
//                         min_notional: Decimal::from_str(price_filter["minPrice"].as_str().unwrap()).unwrap(),
//                         max_notional: Decimal::from_str(price_filter["maxPrice"].as_str().unwrap()).unwrap(),
//                         ct_val: Decimal::ONE,
//                     };
//                     Ok(result)
//                 }
//             }
//         } else {
//             Err(Error::new(ErrorKind::Other, res_data.to_string()))
//         }
//     }
//
//     // 获取订单详情
//     async fn get_order_detail(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//     // 获取订单列表
//     async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//     // 下单接口
//     async fn take_order(&mut self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     async fn take_order_symbol(&mut self, _symbol: String, _ct_val: Decimal, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     // 撤销订单
//     async fn cancel_order(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//     // 批量撤销订单
//     async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     async fn take_stop_loss_order(&mut self, _stop_price: Decimal, _price: Decimal, _side: &str) -> Result<Value, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     async fn cancel_stop_loss_order(&mut self, _order_id: &str) -> Result<Value, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     // 设置持仓模式
//     async fn set_dual_mode(&mut self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     // 更新双持仓模式下杠杆
//     async fn set_dual_leverage(&mut self, _leverage: &str) -> Result<String, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
//
//     async fn set_auto_deposit_status(&mut self, _status: bool) -> Result<String, Error> { Err(Error::new(ErrorKind::NotFound, "coinsph：该交易所方法未实现".to_string())) }
//
//     // 交易账户互转
//     async fn wallet_transfers(&mut self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> {
//         Err(Error::new(ErrorKind::NotFound, "coinsph_swap：该交易所方法未实现".to_string()))
//     }
// }