Trading

use tigeropen::client::http_client::HttpClient;
use tigeropen::config::ClientConfig;
use tigeropen::model::order::limit_order;
use tigeropen::model::trade_requests::{OrdersRequest, PositionsRequest};
use tigeropen::trade::TradeClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig::builder().build()?;
    let account = config.account.clone();
    let http = HttpClient::new(config);
    let tc = TradeClient::new(&http, &account);

    // Query positions (v0.4.0: Request struct)
    let positions = tc.get_positions(PositionsRequest::default()).await?;
    println!("positions={}", positions.len());

    // Build a limit order via helper
    let mut order = limit_order(&account, "AAPL", "STK", "BUY", 100, 150.0);
    order.market = Some("US".into());
    order.currency = Some("USD".into());

    // Preview before placing
    if let Some(preview) = tc.preview_order(order.clone()).await? {
        println!("commission={} initMargin={}", preview.commission, preview.init_margin);
    }

    // Place the order
    if let Some(placed) = tc.place_order(order).await? {
        println!("id={} orderId={}", placed.id, placed.order_id);
    }

    Ok(())
}

use tigeropen::model::enums::OrderStatus;

println!("{}", OrderStatus::Filled.code());        // 6
println!("{}", OrderStatus::PendingSubmit.code());  // 8

pub async fn get_contract(&self, symbol: &str, sec_type: &str) -> Result<Vec<Contract>, TigerError>

let contracts = tc.get_contract("AAPL", "STK").await?;

pub async fn get_contracts(&self, symbols: &[&str], sec_type: &str) -> Result<Vec<Contract>, TigerError>

let contracts = tc.get_contracts(&["AAPL", "TSLA", "MSFT"], "STK").await?;

pub async fn get_quote_contract(&self, symbol: &str, sec_type: &str, expiry: &str) -> Result<Vec<Contract>, TigerError>

let contracts = tc.get_quote_contract("AAPL", "OPT", "20260619").await?;

pub async fn place_order(&self, order: OrderRequest) -> Result<Option<PlaceOrderResult>, TigerError>

if let Some(placed) = tc.place_order(req).await? {
    println!("id={} orderId={}", placed.id, placed.order_id);
}

pub async fn preview_order(&self, order: OrderRequest) -> Result<Option<PreviewResult>, TigerError>

pub async fn modify_order(&self, id: i64, order: OrderRequest) -> Result<Option<OrderIdResult>, TigerError>

pub async fn cancel_order(&self, id: i64) -> Result<Option<OrderIdResult>, TigerError>

use tigeropen::model::trade_requests::OrdersRequest;

// Simple call
let orders = tc.get_orders(OrdersRequest::default()).await?;

// Filtered: last 100 filled US stock orders
let filtered = tc.get_orders(OrdersRequest {
    market: Some("US".to_string()),
    sec_type: Some("STK".to_string()),
    states: Some(vec!["Filled".to_string()]),
    limit: Some(100),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::GetOrderRequest;

let order = tc.get_order(GetOrderRequest {
    id: Some(123456789),
    ..Default::default()
}).await?;

let active = tc.get_active_orders(OrdersRequest::default()).await?;

let inactive = tc.get_inactive_orders(OrdersRequest::default()).await?;

use std::time::{SystemTime, UNIX_EPOCH};

let now = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_millis() as i64).unwrap_or(0);
let recent = tc.get_filled_orders(OrdersRequest {
    start_date: Some(now - 30 * 24 * 3600 * 1000),
    end_date: Some(now),
    limit: Some(200),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::OrderTransactionsRequest;

let txs = tc.get_order_transactions(OrderTransactionsRequest {
    order_id: Some(12345),
    symbol: Some("AAPL".to_string()),
    sec_type: Some("STK".to_string()),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::PositionsRequest;

let positions = tc.get_positions(PositionsRequest::default()).await?;

// Filter to US stocks only
let us = tc.get_positions(PositionsRequest {
    market: Some("US".to_string()),
    sec_type: Some("STK".to_string()),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::AssetsRequest;

let assets = tc.get_assets(AssetsRequest::default()).await?;

if let Some(pa) = tc.get_prime_assets(AssetsRequest::default()).await? {
    println!("account={} segments={}", pa.account_id, pa.segments.len());
}

use tigeropen::model::trade_requests::ManagedAccountsRequest;

let subs = tc.get_managed_accounts(ManagedAccountsRequest::default()).await?;
for s in &subs {
    println!("{} type={:?} status={:?}", s.account, s.account_type, s.status);
}

use tigeropen::model::trade_requests::DerivativeContractsRequest;

let cs = tc.get_derivative_contracts(DerivativeContractsRequest {
    symbols: vec!["AAPL".to_string()],
    sec_type: "OPT".to_string(),
    expiry: Some("20260619".to_string()),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::AnalyticsAssetRequest;

let rows = tc.get_analytics_asset(AnalyticsAssetRequest {
    start_date: Some("2025-01-01".to_string()),
    end_date: Some("2025-12-31".to_string()),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::AggregateAssetsRequest;

if let Some(agg) = tc.get_aggregate_assets(AggregateAssetsRequest {
    base_currency: Some("USD".to_string()),
    ..Default::default()
}).await? {
    println!("netLiq={:?} currencies={}", agg.net_liquidation, agg.currency_assets.len());
}

use tigeropen::model::trade_requests::EstimateTradableQuantityRequest;

if let Some(est) = tc.get_estimate_tradable_quantity(EstimateTradableQuantityRequest {
    symbol: "AAPL".to_string(),
    sec_type: "STK".to_string(),
    action: "BUY".to_string(),
    order_type: Some("LMT".to_string()),
    limit_price: Some(150.0),
    ..Default::default()
}).await? {
    println!("tradable={:?}", est.tradable_quantity);
}

use tigeropen::model::trade_requests::FundDetailsRequest;

let rows = tc.get_fund_details(FundDetailsRequest {
    currency: Some("USD".to_string()),
    limit: Some(100),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::FundingHistoryRequest;

let rows = tc.get_funding_history(FundingHistoryRequest::default()).await?;

use tigeropen::model::trade_requests::ForexOrderRequest;

if let Some(res) = tc.place_forex_order(ForexOrderRequest {
    source_currency: "USD".to_string(),
    source_amount: Some(10000.0),
    target_currency: "HKD".to_string(),
    ..Default::default()
}).await? {
    println!("rate={:?} target={:?}", res.rate, res.target_amount);
}