Skip to content

Get All Orders

Overview

The "Get All Orders" feature allows traders and brokers to retrieve a comprehensive list of all orders placed within their trading accounts. This functionality serves as a valuable tool for efficiently managing trading activities, providing users with a clear overview of their entire order history. Whether you need to monitor open positions, review past transactions, or evaluate your trading strategy, this feature equips you with the tools to make well-informed decisions and enhance your trading experience.

How to Obtain a List of all Orders

In this article you will learn how to get a list of all orders using the order manager. Orders are instructions to buy or sell an instrument at a specified price, volume, and time. You can get a list of all orders, or filter them by instrument, status, or type.

To get a list of all orders, you need to follow these steps:

  1. Login (see the tutorial here).

  2. Create an order manager and subscribe to the state change event.

  3. Get a list of all orders.

  4. Create an order printer.

Step 1: Login

Follow the steps in the login tutorial [here](../../gettingstarted/authentication/performing_login.md).

Step 2: Create an Order Manager and Subscribe to the State Change Event

The state change event is an event that occurs when the order manager's state changes. The state can change due to new orders, modified orders, cancelled orders, or executed orders. To subscribe to the state change event, you need to create a listener function that implements the `IStateChangeListener` interface. The listener function has one method: `onStateChanged()`. The method is called when the state change event occurs. Below, you can see some example code to subscribe to the state change event:

Subscribe to the state change event

=== "Node TypeScript" 
session.getOrdersManager().subscribeStateChange(completeHandler); //get orders manager
session.getOrdersManager().refresh();
=== "Node JavaScript" 
let ordersManager = session.getOrdersManager();
await update(ordersManager)
=== "JavaScript" The first thing we will need to do here is to create the `orders\order-worker.js` file which will be responsible for collecting all the details for each order and passing them to the Order table class which will print the table of data. 
class OrderWorker {
    constructor() {
        this.tableBuilder = new OrderTableBuilder();
    }

    #getDataManagerStateString(state) {
        if (state.isNotLoaded())
            return 'not loaded';

        if (state.isLoading())
            return 'loading';

        if (state.isLoaded())
            return 'loaded';

        return '(has error)'
    }

    #getOrderDetails(order) {
        return new Map([
            ['Order id', order.getOrderId()],
            ['Account name', order.getAccountId()],
            ['Account kind', order.getOfferId()],
            ['Offer id', order.getAmount()],
            ['Amount', order.getRate()],
            ['BuySell', order.getType()],
            ['Open rate', order.getStatus()],
            ['Open time', order.getBuySell()]
        ]);
    }

    showOrderDetails(order) {
        let id = order.getOrderId();

        let orderDetails = this.#getOrderDetails(order);
        this.tableBuilder.renderOrderDetailsSubtable(id, orderDetails);
    }

    showOrders(orders) {
        this.tableBuilder.renderOrderTable(orders, this);
    }

    updateState(state) {
        document.getElementById('ordersState')
            .textContent = this.#getDataManagerStateString(state);
    }
}
Now we can create the *order Listener* in `orders\order-state-listener.js` which is used to listen for changes to the orders list. 
class OrderStateListener {
    constructor(orderManager, orderWorker) {
        this.orderManager = orderManager;
        this.orderWorker = orderWorker;
    }

    onStateChange(state) {
        this.orderWorker.updateState(state);
        if (state.isLoaded()) {
            let orders = this.orderManager.getOrdersSnapshot();
            this.orderWorker.showOrders(orders);
        }
    }
}
Finally we can subscribe to this listener from our `index.js` file 
const sessionFactory = FXConnectLite.FXConnectLiteSessionFactory
const LoggerFactory = FXConnectLite.LoggerFactory

let ordersWorker;

document.addEventListener('DOMContentLoaded', () => {
    let session = sessionFactory.create('GetOrdersSample');
    session.setLogger(LoggerFactory.createLogger(LoggerFactory.LEVEL_DEBUG));

    let orderManager = session.getOrdersManager();
    session.subscribeConnectionStatusChange(new ConnectionStatusChangeListener(session, orderManager));

    let orderWorker = new OrderWorker();
    orderWorker.updateState(orderManager.getState());
    orderManager.subscribeStateChange(new OrderStateListener(orderManager, orderWorker));

    document.getElementById('btnRefreshAllOrders')
        .onclick = () => orderManager.refresh();

    bindConnectionRelatedEvents(session);
});
=== "Java" 
session.getOrdersManager().subscribeStateChange(s -> {
//do something
});
session.getOrdersManager().refresh();
See also [subscribeStateChange](../../core/core.interfaces.tradingdata/classes/IDataProviderMethods/IDataProvider.subscribeStateChange.md), [refresh()](../../core/core.interfaces.tradingdata/classes/IDataManagerMethods/IDataManager.refresh.md)

Step 3: Getting a List of all Orders

To get a list of all orders, you can use the order manager's `getOrdersSnapshot` method. This method returns a list of all orders that are currently in the order manager's state. You can use the order printer to print the details of each order. Below, you can see some example code for `getOrdersSnapshot`:

To get orders snapshot

=== "Node TypeScript" 
let ordersManager = session.getOrdersManager();
OrderPrinter.printAll(ordersManager.getOrdersSnapshot()); // get orders snapshot
=== "Node JavaScript" 
let orderWorker = new OrderWorker();
orderWorker.showOrdersDetails(orders);
=== "Java" 
final IOrdersManager ordersManager = session.getOrdersManager();
Order[] orders = ordersManager.getOrdersSnapshot();
=== "JavaScript" The snapshot we already get in the order state listener class, inside the onChangeState method.
However, one of the final things we need to do is to refresh the order manager so that it will populate the orders list 
const sessionFactory = FXConnectLite.FXConnectLiteSessionFactory
const LoggerFactory = FXConnectLite.LoggerFactory

let ordersWorker;

document.addEventListener('DOMContentLoaded', () => {
    let session = sessionFactory.create('GetOrdersSample');
    session.setLogger(LoggerFactory.createLogger(LoggerFactory.LEVEL_DEBUG));

    let orderManager = session.getOrdersManager();
    session.subscribeConnectionStatusChange(new ConnectionStatusChangeListener(session, orderManager));

    let orderWorker = new OrderWorker();
    orderWorker.updateState(orderManager.getState());
    orderManager.subscribeStateChange(new OrderStateListener(orderManager, orderWorker));

    document.getElementById('btnRefreshAllOrders')
        .onclick = () => orderManager.refresh();

    bindConnectionRelatedEvents(session);
});
We should also declare an instance of the ordersWorker directly after the document is loaded. 
ordersWorker = new OrdersWorker();
To use the listener function, you need to subscribe it to the `OrderManager` using the `subscribeStateChange()` method. You also need to call the `refresh()` method to initialize the order manager's state. See also [IOrdersManager](../../core/core.interfaces.tradingdata.orders/classes/IOrdersManager.md), [getOrdersSnapshot](../../core/core.interfaces.tradingdata.orders/classes/IOrdersManagerMethods/IOrdersManager.getOrdersSnapshot.md)

Step 4: Creating an Order Printer

An order printer is a function that takes an order as an argument and prints its base properties. The base properties are: | | | |----------|----------| | id | The unique identifier of the order | | symbol | The instrument symbol of the order | | side | The direction (buy or sell) of the order | | type | The type (market, limit, stop, etc.) of the order | | volume | The amount of units of the instrument to buy or sell | | price | The price at which the order is executed | | status | The status (pending, filled, cancelled, etc.) of the order | Below, you can see some example code for the order printer :

The order printer

=== "Node TypeScript" 
class OrderPrinter {

    public static print(order: FXConnectLite.Order): void {
        Printer.print(`OrderId = ${order.getOrderId()} AccountId = ${order.getAccountId()} OfferId = ${order.getOfferId()} Amount = ${order.getAmount()} Rate = ${order.getRate()} Type = ${order.getType()} Status = ${order.getStatus()} BuySell = ${order.getBuySell()}`)
    }

    public static printAll(orders: FXConnectLite.Order[]): void {
        Printer.print(`Current orders snapshot:`);
        Printer.print(`Number of orders is ${orders.length}`);
        orders.forEach(order => {
            OrderPrinter.print(order);
        });
    }
}
=== "Node JavaScript" 
class OrderWorker {
    showOrderDetails(order) {
        let orderDetails = `
        OrderId = ${order.getOrderId()}
        AccountId = ${order.getAccountId()}
        OfferId = ${order.getOfferId()}
        Amount = ${order.getAmount()}
        Rate = ${order.getRate()}
        Type = ${order.getType()}
        Status = ${order.getStatus()}
        BuySell = ${order.getBuySell()}
        `;

        console.log('Account details:');
        console.log(orderDetails);
    }


    showOrdersDetails(orders) {
        console.log(`Number of orders is ${orders.length}`);

        orders.forEach((order) => {
            this.showOrderDetails(order);
        });
    }
}
=== "JavaScript" For printing the results of the command, we have first created a file which will contain our `TableBuilder` class. Follow the instruction in the Table Builder tutorial [here](../../gettingstarted/authentication/performing_login.md). Next we will create the file `orders\order-table-builder.js` which will use the previous `TableBuilder` class and will populate all of the values in the table. 
class OrderTableBuilder {
    constructor() {
        this.builder = new TableBuilder();
    }

    #onOrderClick(order, orderWorker) {
        let callback = function () {
            orderWorker.showOrderDetails(order);
        }

        this.builder.onRowClick(order.getOrderId(), callback);
    }

    #onSubtableClick() {
        this.builder.removeSubtable();
    }

    #renderDataTableRow(order, orderWorker) {
        let columns = [
            { className: 'col-sm-2', value: order.getOrderId() },
            { className: 'col-sm-2', value: order.getAccountId() },
            { className: 'col-sm-2', value: order.getOfferId() },
            { className: 'col-sm-3', value: order.getAmount() },
            { className: 'col-sm-3', value: order.getRate() }
        ];

        let row = this.builder.createDataTableRow(columns);
        row.onclick = () => this.#onOrderClick(order, orderWorker);
    }

    #renderNoOrdersMessage() {
        let columns = [
            { className: 'col-sm-12', value: 'No Orders' }
        ];

        this.builder.createDataTableRow(columns);
    }

    #renderOrderTableHeader() {
        let columns = [
            { className: 'col-sm-2', value: 'Order ID' },
            { className: 'col-sm-2', value: 'Account ID' },
            { className: 'col-sm-2', value: 'Offer ID' },
            { className: 'col-sm-3', value: 'Amount' },
            { className: 'col-sm-3', value: 'Rate' }
        ];

        this.builder.createHeaderTableRow(columns);
    }

    renderOrderDetailsSubtable(id, details) {
        let columns = [];
        details.forEach((k, v) => {
            columns.push({ className: 'col-sm-6', value: v });
            columns.push({ className: 'col-sm-6', value: k });
        });

        let detailsRow = this.builder.createDataSubtable(id, columns, 'row mb-3 details');
        detailsRow.onclick = () => this.#onSubtableClick();
    }

    renderOrderTable(orders, orderWorker) {
        this.#renderOrderTableHeader();

        if (orders.length === 0) {
            this.#renderNoOrdersMessage();
        } else {
            for (let order of orders)
                this.#renderDataTableRow(order, orderWorker);
        }

        this.builder.showContainer();
    }
}
=== "Java" 
System.out.printIn("Number of Orders: " + orders.length);
for (Order order : orders) {
System.out.printf("%s %s %d%n", order.getOrderId(), order.getOfferId(), order.getAmount());
}
See also [Order](../../core/core.entity.order/classes/Order.md) When you have a list of all orders, you can: 1. [Get available instruments](../../trading/instruments/get_available_instruments.md). 2. [Subscribe and Unsubscribe to instruments](../../trading/instruments/subscribe_instruments.md). 3. [Get price updates for an instrument](../../trading/prices/get_a_price_update_for_an_instrument.md). 4. [Get historical prices for an instrument](../../trading/prices/get_historical_prices_for_an_instrument.md). 5. [Create a market order](../../trading/orders/create_a_market_order.md). 6. [Create an entry order](../../trading/orders/create_an_entry_order.md). 7. [Get open positions](../../trading/positions/get_a_list_of_open_positions.md).

Conclusion

You have learned how to get a list of all orders using the `OrderManager`. Orders are instructions to buy or sell an instrument at a specified price, volume, and time. Before you can get a list of all orders, you need to create an order manager, subscribe to the state change event, and create an order printer. The state change event is an event that occurs when the order manager's state changes due to new orders, modified orders, cancelled orders, or executed orders. You can subscribe to the state change event by creating a listener function that implements the `IStateChangeListener` interface and subscribing it to the order manager using the subscribeStateChange method. You can also get a list of all orders by using the order manager's `getOrdersSnapshot()` method. You can now use this knowledge to manage your orders on the platform. Download the sample [Node TypeScript](../../html/samples/node-ts/get_orders.zip){:target="_blank"}, [Node JavaScript](../../html/samples/node-js/get_orders.zip){:target="_blank"}, [Javascript](../../html/samples/js/get_orders.zip){:target="_blank"}. You can also download samples of how to get offers [Node TypeScript](../../html/samples/node-ts/get_offers.zip){:target="_blank"}, [Node JavaScript](../../html/samples/node-js/get_offers.zip){:target="_blank"}, [Javascript](../../html/samples/js/get_offers.zip){:target="_blank"}.
Table of Contents
Order Types
This page will explain each of the different types of orders in the system.
Get All Orders
The article teaches how to get a list of all orders.
Modify an Order
The article teaches how to modify an order
Create a Market Order
The article teaches how to create a market order
Create an Entry Order
API Command used to create an entry order
Create a Close Market Order
The article teaches how to create a close 'market order'
Create an OCO Order
API Command used to create an OCO order
Create a Stop and/or Limit Order
This article provides information about how to add a stop/limit to an order
Cancel an Order
This article provides information about how to cancel an order