Trading

use tigeropen::config::ClientConfig;
use tigeropen::trade::{TradeClient, Order};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig::from_properties_file("tiger_openapi_config.properties")?;
    let account = config.account.clone();
    let tc = TradeClient::new(config);

    // Build a limit order
    let order = Order {
        account: account.clone(),
        symbol: "AAPL".to_string(),
        sec_type: "STK".to_string(),
        action: "BUY".to_string(),
        order_type: "LMT".to_string(),
        total_quantity: 100,
        limit_price: Some(150.0),
        time_in_force: "DAY".to_string(),
        ..Default::default()
    };

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

    // Place the order
    let result = tc.place_order(order).await?;
    println!("Order ID: {}", result.id);

    Ok(())
}

use tigeropen::trade::Order;

// Stock limit buy
let limit_order = Order {
    account: account.clone(),
    symbol: "AAPL".to_string(),
    sec_type: "STK".to_string(),
    action: "BUY".to_string(),
    order_type: "LMT".to_string(),
    total_quantity: 100,
    limit_price: Some(150.0),
    time_in_force: "DAY".to_string(),
    ..Default::default()
};

// Stock market sell
let market_order = Order {
    account: account.clone(),
    symbol: "TSLA".to_string(),
    sec_type: "STK".to_string(),
    action: "SELL".to_string(),
    order_type: "MKT".to_string(),
    total_quantity: 50,
    time_in_force: "DAY".to_string(),
    ..Default::default()
};

// Option limit buy (call)
let option_order = Order {
    account: account.clone(),
    symbol: "AAPL".to_string(),
    sec_type: "OPT".to_string(),
    action: "BUY".to_string(),
    order_type: "LMT".to_string(),
    total_quantity: 1,
    limit_price: Some(5.50),
    time_in_force: "DAY".to_string(),
    expiry: Some("20250117".to_string()),
    strike: Some(150.0),
    right: Some("CALL".to_string()),
    ..Default::default()
};

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

let contract = tc.contract("AAPL", "STK").await?;
println!("Exchange: {}", contract.exchange);

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

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

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

let quote_contract = tc.quote_contract("AAPL", "OPT").await?;

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

let result = tc.place_order(limit_order).await?;
println!("Order ID: {}", result.id);
// PlaceOrderResult { id: 123456789, status: "Submitted" }

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

let preview = tc.preview_order(limit_order.clone()).await?;
println!("Commission: {:?}", preview.commission);
println!("Margin impact: {:?}", preview.margin_impact);

pub async fn modify_order(&self, id: i64, order: Order) -> Result<ModifyResult, TigerError>

let mut updated = limit_order.clone();
updated.limit_price = Some(148.0);
let mod_result = tc.modify_order(123456789, updated).await?;

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

let cancel_result = tc.cancel_order(123456789).await?;

pub async fn get_orders(&self) -> Result<Vec<OrderInfo>, TigerError>

let orders = tc.orders().await?;
println!("Total orders today: {}", orders.len());

pub async fn get_active_orders(&self) -> Result<Vec<OrderInfo>, TigerError>

let active_orders = tc.active_orders().await?;
println!("Open orders: {}", active_orders.len());

pub async fn get_inactive_orders(&self) -> Result<Vec<OrderInfo>, TigerError>

let inactive_orders = tc.inactive_orders().await?;

pub async fn get_filled_orders(&self) -> Result<Vec<OrderInfo>, TigerError>

let filled_orders = tc.filled_orders().await?;

pub async fn get_positions(&self) -> Result<Vec<Position>, TigerError>

let positions = tc.positions().await?;
for p in &positions {
    println!("{}: qty={} unrealized_pnl={:?}", p.symbol, p.quantity, p.unrealized_pnl);
}

pub async fn get_assets(&self) -> Result<Assets, TigerError>

let assets = tc.assets().await?;
println!("Net liquidation: {:?}", assets.net_liquidation);
println!("Buying power: {:?}", assets.buying_power);

pub async fn get_prime_assets(&self) -> Result<PrimeAssets, TigerError>

let prime_assets = tc.prime_assets().await?;

pub async fn get_order_transactions(&self, id: i64) -> Result<Vec<Transaction>, TigerError>

let transactions = tc.order_transactions(123456789).await?;
for tx in &transactions {
    println!("Fill: price={} qty={}", tx.price, tx.quantity);
}

use tigeropen::config::ClientConfig;
use tigeropen::client::HttpClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig::from_properties_file("tiger_openapi_config.properties")?;
    let http_client = HttpClient::new(config);

    // Pass the API method name and a raw JSON parameter string
    let resp = http_client
        .execute("market_state", r#"{"market":"US"}"#)
        .await?;
    println!("Raw response: {}", resp);

    Ok(())
}