Struct Order

Source

pub struct Order {
    pub message: String,
    pub order_id: String,
    pub error: Option<String>,
}

Expand description

An Active Order

Fields§

§message: String

Short text summary / description of the order.

§order_id: String

The id of the order.

§error: Option<String>

The error for the order.

Implementations§

Source §

impl Order

Source

pub async fn confirm( client: &mut Client, order_request: &OrderRequest, ) -> Result<Vec<OrderConfirmation>, Error>

Confirm an order getting back an estimated cost and commission information for the order without actually placing the order.

NOTE: Only valid for Market Limit, Stop Market, Options, and Order Sends Order (OSO) order types.

§Example

Confirm a limit buy order for 3 Month SOFR Futures at the March 2025 contract @ 96.0725 with a quantity of 50 contracts and a duration of Good Till Close (GTC).

use tradestation::{
    ClientBuilder, Error, Token,
    execution::{Duration, OrderRequestBuilder, Order},
};

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Create client
    let mut client = ClientBuilder::new()?
        .credentials("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")?
        .token(Token { /* YOUR BEARER AUTH TOKEN */ })?
        .build()
        .await?;

    let order_req = OrderRequestBuilder::new()
        .account_id("YOUR_FUTURES_ACCOUNT_ID")
        .symbol("SR3H25")
        .trade_action(TradeAction::Buy)
        .quantity("50")
        .order_type(OrderType::Limit)
        .limit_price("96.0725")
        .time_in_force(OrderTimeInForce {
            duration: Duration::GTC,
            expiration: None,
        })
        .build()?;

    match Order::confirm(&mut client, &order_req).await {
        Ok(confirmation) => println!("Confirmed Order: {confirmation:?}"),
        Err(e) => println!("Issue Confirming Order: {e:?}"),
    };
    Ok(())
}

Source

pub async fn place( client: &mut Client, order_request: &OrderRequest, ) -> Result<Vec<Order>, Error>

Place the OrderRequest getting back the result of the Order Request.

§Example

Place an order to buy 100 shares of JP Morgan ("JPM") using a limit order with the limit price of $"220.50", with a order duration of Good Till Closed.

 let order_req = OrderRequestBuilder::new()
     .account_id("YOUR_EQUITIES_ACCOUNT_ID")
     .symbol("JPM")
     .trade_action(TradeAction::Buy)
     .quantity("100")
     .order_type(OrderType::Limit)
     .limit_price("220.50")
     .time_in_force(OrderTimeInForce {
         duration: Duration::GTC,
         expiration: None,
     })
     .build()?;

 match Order::place(&mut client, order_req).await {
     Ok(resp) => println!("Order Response: {resp:?}"),
     Err(e) => println!("Order Response: {e:?}"),
 }

Source

pub async fn confirm_group( client: &mut Client, order_req_group: &OrderRequestGroup, ) -> Result<Vec<OrderConfirmation>, Error>

Creates an Order Confirmation for a group order. Request valid for Order Cancels Order (OCO) and Bracket (BRK) order types as well as grouped orders of other types (NORMAL).

§Order Cancels Order (OCO)

An OCO order is a group of orders whereby if one of the orders is filled or partially-filled, then all of the other orders in the group are cancelled.

§Bracket OCO Orders

A bracket order is a special instance of an OCO (Order Cancel Order). Bracket orders are used to exit an existing position. They are designed to limit loss and lock in profit by “bracketing” an order with a simultaneous stop and limit order.

Bracket orders are limited so that the orders are all for the same symbol and are on the same side of the market (either all to sell or all to cover), and they are restricted to closing transactions.

The reason that they follow these rules is because the orders need to be able to auto decrement when a partial fill occurs with one of the orders. For example, if the customer has a sell limit order for 1000 shares and a sell stop order for 1000 shares, and the limit order is partially filled for 500 shares, then the customer would want the stop to remain open, but it should automatically decrement the order to 500 shares to match the remaining open position.

NOTE: When a group order is submitted, the order execution system treats each sibling order as an individual order. Thus, the system does not validate that each order has the same Quantity, and currently it is not able to update a bracket order as one transaction, instead you must update each order within a bracket.

§Example

Confirm a trade involving a bracket group of orders with one order for opening the position, one order for closing the position at a take profit price, and one order for closing the position at a stop loss price. A total of 3 orders making up this position.

use tradestation::{
    execution::{Duration, Order, OrderRequestBuilder},
    ClientBuilder, Error, Token,
};

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Create client
    let mut client = ClientBuilder::new()?
        .credentials("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")?
        .token(Token { /* YOUR BEARER AUTH TOKEN */ })?
        .build()
        .await?;

    let entry_order_req = OrderRequestBuilder::new()
        .account_id("YOUR_EQUITIES_ACCOUNT_ID")
        .symbol("XLRE")
        .trade_action(TradeAction::SellShort)
        .quantity("1000")
        .order_type(OrderType::Market)
        .time_in_force(OrderTimeInForce {
            duration: Duration::GTC,
            expiration: None,
        })
        .build()?;

    let take_profit_order_req = OrderRequestBuilder::new()
        .account_id("YOUR_EQUITIES_ACCOUNT_ID")
        .symbol("XLRE")
        .trade_action(TradeAction::BuyToCover)
        .quantity("1000")
        .order_type(OrderType::Limit)
        .limit_price("35.75")
        .time_in_force(OrderTimeInForce {
            duration: Duration::GTC,
            expiration: None,
        })
        .build()?;

    let stop_loss_order_req = OrderRequestBuilder::new()
        .account_id("YOUR_EQUITIES_ACCOUNT_ID")
        .symbol("XLRE")
        .trade_action(TradeAction::BuyToCover)
        .quantity("1000")
        .order_type(OrderType::StopMarket)
        .stop_price("46.50")
        .time_in_force(OrderTimeInForce {
            duration: Duration::GTC,
            expiration: None,
        })
        .build()?;

    let order_group = OrderRequestGroupBuilder::new()
        .order_requests(Vec::from([
            entry_order_req,
            take_profit_order_req,
            stop_loss_order_req,
        ]))
        .group_type(OrderGroupType::BRK)
        .build()?;

    let order_confirmations = Order::confirm(&mut client, &order_group).await?;
    println!("Confirm Orders Result: {order_confirmations:?}");
}

Source

pub async fn place_group( client: &mut Client, order_req_group: &OrderRequestGroup, ) -> Result<Vec<Order>, Error>

Submits a group order. Request valid for Order Cancels Order (OCO) and Bracket (BRK) order types as well as grouped orders of other types (NORMAL).

§Order Cancels Order (OCO)

An OCO order is a group of orders whereby if one of the orders is filled or partially-filled, then all of the other orders in the group are cancellCreates an Order Confirmation for a group order. Request valid for all account types. Request valid for Order Cancels Order (OCO) and Bracket (BRK) order types as well as grouped orders of other types (NORMAL).ed.

§Bracket OCO Orders

A bracket order is a special instance of an OCO (Order Cancel Order). Bracket orders are used to exit an existing position. They are designed to limit loss and lock in profit by “bracketing” an order with a simultaneous stop and limit order.

Bracket orders are limited so that the orders are all for the same symbol and are on the same side of the market (either all to sell or all to cover), and they are restricted to closing transactions.

The reason that they follow these rules is because the orders need to be able to auto decrement when a partial fill occurs with one of the orders. For example, if the customer has a sell limit order for 1000 shares and a sell stop order for 1000 shares, and the limit order is partially filled for 500 shares, then the customer would want the stop to remain open, but it should automatically decrement the order to 500 shares to match the remaining open position.

NOTE: When a group order is submitted, the order execution system treats each sibling order as an individual order. Thus, the system does not validate that each order has the same Quantity, and currently it is not able to update a bracket order as one transaction, instead you must update each order within a bracket.

§Example

Place a trade involving a bracket group of orders with one order for opening the position, one order for closing the position at a take profit price, and one order for closing the position at a stop loss price. A total of 3 orders making up this position.

use tradestation::{
    execution::{Duration, Order, OrderRequestBuilder},
    ClientBuilder, Error, Token,
};

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Create client
    let mut client = ClientBuilder::new()?
        .credentials("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")?
        .token(Token { /* YOUR BEARER AUTH TOKEN */ })?
        .build()
        .await?;

    let entry_order_req = OrderRequestBuilder::new()
        .account_id("YOUR_EQUITIES_ACCOUNT_ID")
        .symbol("XLRE")
        .trade_action(TradeAction::SellShort)
        .quantity("1000")
        .order_type(OrderType::Market)
        .time_in_force(OrderTimeInForce {
            duration: Duration::GTC,
            expiration: None,
        })
        .build()?;

    let take_profit_order_req = OrderRequestBuilder::new()
        .account_id("YOUR_EQUITIES_ACCOUNT_ID")
        .symbol("XLRE")
        .trade_action(TradeAction::BuyToCover)
        .quantity("1000")
        .order_type(OrderType::Limit)
        .limit_price("35.75")
        .time_in_force(OrderTimeInForce {
            duration: Duration::GTC,
            expiration: None,
        })
        .build()?;

    let stop_loss_order_req = OrderRequestBuilder::new()
        .account_id("YOUR_EQUITIES_ACCOUNT_ID")
        .symbol("XLRE")
        .trade_action(TradeAction::BuyToCover)
        .quantity("1000")
        .order_type(OrderType::StopMarket)
        .stop_price("46.50")
        .time_in_force(OrderTimeInForce {
            duration: Duration::GTC,
            expiration: None,
        })
        .build()?;

    let order_group = OrderRequestGroupBuilder::new()
        .order_requests(Vec::from([
            entry_order_req,
            take_profit_order_req,
            stop_loss_order_req,
        ]))
        .group_type(OrderGroupType::BRK)
        .build()?;

    let orders = Order::place_group(&mut client, &order_group).await?;
    println!("Place Orders Result: {orders:?}");
}

Source

pub async fn replace( self, client: &mut Client, order_update: OrderUpdate, ) -> Result<Vec<Order>, Error>

Replace an Order with an Order Update.

§Example

Replace an order to buy 100 shares of Palantir "PLTR" at the limit price of $"40.00" to instead be 25 shares at the limit price of $"42.50".

let order_req = OrderRequestBuilder::new()
    .account_id("YOUR_EQUITIES_ACCOUNT_ID")
    .symbol("PLTR")
    .trade_action(TradeAction::Buy)
    .quantity("100")
    .order_type(OrderType::Limit)
    .limit_price("40.00")
    .time_in_force(OrderTimeInForce {
        duration: Duration::GTC,
        expiration: None,
    })
    .build()?;

let order = Order::place(&mut client, &order_req)
    .await?
    .into_iter()
    .next();

if let Some(order) = order {
    order
        .clone()
        .replace(
            &mut client,
            OrderUpdate::new().limit_price("42.50").quantity("25"),
        )
        .await?;
}

Source

pub async fn cancel(self, client: &mut Client) -> Result<Vec<Order>, Error>

Cancel an active Order.

§Example

let order_req = OrderRequestBuilder::new()
    .account_id("YOUR_EQUITIES_ACCOUNT_ID")
    .symbol("JPM")
    .trade_action(TradeAction::Buy)
    .quantity("100")
    .order_type(OrderType::Limit)
    .limit_price("220.50")
    .time_in_force(OrderTimeInForce {
        duration: Duration::GTC,
        expiration: None,
    })
    .build()?;

let order = Order::place(&mut client, &order_req)
    .await?
    .into_iter()
    .next();

if let Some(order) = order {
    order.cancel(&mut client).await?;
}