Create An Entry Order

Overview

An entry order is a trader's instruction to enter the market at a specific price of their choosing. It's a strategic move, often driven by their analysis of market conditions.

For example, if a trader believes a particular asset will become more favorable at a specific price point, they can place an entry order there. This approach grants traders control over their entry, helping them align their trading strategies with market opportunities.

However, it's important to remember that entry orders don't guarantee execution; the market must reach the specified price for the trade to proceed. Therefore, traders need to stay vigilant and adapt to ever-changing market dynamics.

How to create an entry order

In this article you will learn how to create an entry order, which is a type of order that is executed when the market price reaches a specified level. You can use entry orders to enter a trade at a favorable price or to set a stop-loss or take-profit for an existing trade. To create an entry order, you need to follow these steps:

Node TypeScriptNode JavaScriptJavaScript

1. Login (see the tutorial here)

2. Create an EntryOrderFactory object.

3. Create an Entry Order Request.

1. Login (see the tutorial here)

2. Create an EntryOrderFactory object.

3. Create an Entry Order Request.

1. Login (see the tutorial here)

2. Create an EntryOrderFactory object.

3. Create an Entry Order Request.

4. Creating Listeners

5. Creating Workers to pass results to be printed.

6. Printing the results in a readable format.

7. Updating the html to include our new JavaScript files.

8. The main JavaScript file.

Step 1: Login

Follow the steps in the login tutorial here

Step 2: Create an EntryOrderFactory object

You need to create an EntryOrderFactory object, which is a helper class that helps you set up the order parameters, such as the instrument, the direction, the amount, the price, and the expiration date. You can use the following code to create an EntryOrderFactory object:

Create the class

Node TypeScriptNode JavaScriptJavaScript

class EntryOrderFactory {
    static create(manager, offersManager, accountId, offerId, amount) {

        let offer = offersManager.getOfferById(offerId);

        return manager.getRequestFactory().createEntryOrderRequestBuilder()
        .setAccountId(accountId)
        .setAmount(amount)
        .setOfferId(offerId)
        .setBuySell('B')
        .setTimeInForce('GTC')
        .setCustomId('custom-id-open')
        .setLimitRate(offer.getAsk() + offer.getAsk() / 90)
        .setStopRate(offer.getAsk() - offer.getAsk() / 100)
        .setRate(offer.getAsk() + offer.getAsk() / 100)
        .setRateRange(10)
        .enableTrailingStop(FXConnectLite.TrailingStopType.Fixed, 10)
        .build();
    }
}    

let EntryOrderFactory = /** @class */ (function () {
    function EntryOrderFactory() {
    }
    EntryOrderFactory.create = function (manager, offersManager, accountId, offerId, amount) {
        let offer = offersManager.getOfferById(offerId);
        return manager.getRequestFactory().createEntryOrderRequestBuilder()
        .setAccountId(accountId)
        .setAmount(amount)
        .setOfferId(offerId)
        .setBuySell('B')
        .setTimeInForce('GTC')
        .setCustomId('custom-id-open')              
        .setLimitRate(offer.getAsk() + offer.getAsk() / 90)
        .setStopRate(offer.getAsk() - offer.getAsk() / 100)
        .setRate(offer.getAsk() + offer.getAsk() / 100)
        .setRateRange(10)
        .enableTrailingStop(FXConnectLite.TrailingStopType.Fixed, 10)
        .build();
    };
    return EntryOrderFactory;
}());

In the JavaScript version we need to create the order worker class orders\order-worker.js. This class is responsible for passing the results to the printing functions and is responsible for creating the order.

class OrderWorker {
    constructor(session, accountCommissionsManager, offersManager) {
        this.accountCommissionsManager = accountCommissionsManager;
        this.offersManager = offersManager;

        this.accountsManager = session.getAccountsManager();
        this.marginProvider = session.getMarginProvider();
        this.tradingSettingsProvider = session.getTradingSettingsProvider();

        this.tableBuilder = new OrderTableBuilder();
    }


    #buildRequest(ordersManager, account, amount, offer) {
        let requestFactory = ordersManager.getRequestFactory();
        return requestFactory.createEntryOrderRequestBuilder()
            .setAccountId(account.getAccountId())
            .setAmount(amount)
            .setOfferId(offer.offerId)
            .setBuySell('B')
            .setTimeInForce('GTC')
            .setCustomId('custom-id-open')
            .setLimitRate(offer.getAsk() + offer.getAsk() / 90)
            .setStopRate(offer.getAsk() - offer.getAsk() / 100)
            .setRate(offer.getAsk() + offer.getAsk() / 100)
            .setRateRange(10)
            .enableTrailingStop(FXConnectLite.TrailingStopType.Fixed, 10)
            .build();
    }


    #getAccount() {
        let accountsInfo = this.accountsManager.getAccountsInfo()[0];
        return this.accountsManager.getAccountById(accountsInfo.getId());
    }


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

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

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

        return '(has error)'
    }


    #getPip(amount, offer, instrument) {
        let pipCost = offer.getPipCost();
        let pipCostAmount = this.tradingSettingsProvider.getPipCostAmount(instrument);

        return amount * pipCost / pipCostAmount;
    }


    placeEntryOrder(ordersManager, instrument) {
        let account = this.#getAccount();
        let amount = this.tradingSettingsProvider.getMinQuantity(instrument, account);
        let offer = this.offersManager.getOfferById(instrument.getOfferId());

        let pip = this.#getPip(amount, offer, instrument);
        console.log(`Per Pip: ${pip}`);

        let commission = this.accountCommissionsManager.getOpenCommission(offer, account, amount, 'B', offer.getAsk());
        console.log(`Commission: ${commission}`);

        let mmr = this.marginProvider.getMMR(instrument, account);
        console.log(`Used Margin: ${mmr}`);

        let request = this.#buildRequest(ordersManager, account, amount, offer);
        ordersManager.createEntryOrder(request);
    }


    showOrderDetails(order) {
        this.tableBuilder.renderOrderDetailsSubtable(order);
    }


    updateState(state) {
        document.getElementById('state')
            .textContent = this.#getDataManagerStateString(state);
    }
}

See also IOrdersManager, getRequestFactory, IOrdersRequestBuilderFactory, EntryOrderRequestBuilder,Get all orders article.

Step 3: Create an Entry Order Request

Now, use the EntryOrderFactory object to create an entry order request, which is an object that contains all the information needed to place the order. You can use the following code to create an entry order request:

Create an entry order

Node TypeScriptNode JavaScriptJavaScript

let offerId = instrument.getOfferId();
const amount = 100; //any integer
//create ordersManager
let manager = session.getOrdersManager();
//create offersManager
let offersManager = session.getOffersManager();
//create accountManager
let accountsManager = session.getAccountsManager();
//get first account
const account = accountsManager.getAccountById(accountsManager.getAccountsInfo()[0].getId());
//create request using our custom order factory
let request = EntryOrderFactory.create(manager, offersManager, account.getAccountId(), offerId, amount);
//create entry order
manager.createEntryOrder(request);

let offerId = instrument.getOfferId();
const amount = 100; //any integer
//create ordersManager
let manager = session.getOrdersManager();
//create offersManager
let offersManager = session.getOffersManager();
//create accountManager
let accountsManager = session.getAccountsManager();
//get first account
const account = accountsManager.getAccountById(accountsManager.getAccountsInfo()[0].getId());
//create request using our custom order factory
let request = EntryOrderFactory.create(manager, offersManager, account.getAccountId(), offerId, amount);
//create entry order
manager.createEntryOrder(request);

In the same file orders\order-worker.js we have the method placeOpenOrder which is responsible for creating the actual order.

placeEntryOrder(ordersManager, instrument) {
    let account = this.#getAccount();
    let amount = this.tradingSettingsProvider.getMinQuantity(instrument, account);
    let offer = this.offersManager.getOfferById(instrument.getOfferId());

    let pip = this.#getPip(amount, offer, instrument);
    console.log(`Per Pip: ${pip}`);

    let commission = this.accountCommissionsManager.getOpenCommission(offer, account, amount, 'B', offer.getAsk());
    console.log(`Commission: ${commission}`);

    let mmr = this.marginProvider.getMMR(instrument, account);
    console.log(`Used Margin: ${mmr}`);

    let request = this.#buildRequest(ordersManager, account, amount, offer);
    ordersManager.createEntryOrder(request);
}

Step 4: Creating Listeners

These listeners listen for changes in both the orders list and the open positions list so that we can pass the changes to be printed. positions\open-position-change-listener.js

class OpenPositionChangeListener {
    constructor(ordersManager) {
        this.ordersManager = ordersManager;
    }

    onChange(openPositionInfo) {
        //do nothing
    }

    onAdd(openPositionInfo) {
        //do nothing
    }

    onDelete(openPositionInfo) {
        //do nothing
    }

    onRefresh() {
        this.ordersManager.refresh();
    }
}

orders\order-change-listener.js

class OrderChangeListener {
    constructor(ordersManager, orderWorker) {
        this.ordersManager = ordersManager;
        this.orderWorker = orderWorker;
    }

    onChange(orderInfo) {
        let order = this.ordersManager.getOrderById(orderInfo.getOrderId());
        console.log(`Order ${orderInfo.getOrderId()} changed to status '${order.getStatus()}'.`);
    }

    onAdd(orderInfo) {
        console.log(`Order ${orderInfo.getOrderId()} added.`);

        let order = this.ordersManager.getOrderById(orderInfo.getOrderId());
        this.orderWorker.showOrderDetails(order);
    }

    onDelete(orderInfo) {
        console.log(`Order ${orderInfo.getOrderId()} deleted.`);
    }

    onError(orderInfo) {
        console.log(`Order error: ${orderInfo.getError().getMessage()}`);
    }
}

orders\order-state-listener.js

class OrderStateListener {
    constructor(instrumentsManager, orderManager, orderWorker) {
        this.instrumentsManager = instrumentsManager;
        this.orderManager = orderManager;
        this.orderWorker = orderWorker;
    }

    onStateChange(state) {
        this.orderWorker.updateState(state);
        if (!state.isLoaded()) 
            return;

        let instrument = this.instrumentsManager.getInstrumentBySymbol('EUR/USD');
        this.orderWorker.placeEntryOrder(this.orderManager, instrument);
    }
}

orders\place-close-order-action.js

class PlaceCloseOrderAction {
    constructor(orderManager) {
        this.ordersManager = orderManager;
    }

    #buildRequest(position) {
        let requestFactory = this.ordersManager.getRequestFactory();
        return requestFactory.createCloseMarketOrderRequestBuilder()
            .setTradeId(position.getTradeID())
            .setAmount(position.getAmount())
            .setRateRange(10)
            .setTimeInForce('IOC')
            .setCustomId('custom-id-close')
            .build();
    }

    execute(position) {
        console.log(`Placing a close market order...`);

        let request = this.#buildRequest(position);
        this.ordersManager.createCloseMarketOrder(request);
    }
}

orders\order-table-builder.js

class OrderTableBuilder {
    constructor() {
        this.builder = new TableBuilder();
    }

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

    #renderOrderTableHeader() {
        let columns = [
            { className: 'col-sm-12', value: 'Entry Order' }
        ];

        return this.builder.createHeaderTableRow(columns);
    }

    renderOrderDetailsSubtable(order) {
        let row = this.#renderOrderTableHeader();

        let details = this.#getOrderDetails(order);
        let columns = this.builder.createDataSubtableColumns(details);

        this.builder.createDataSubtable(row, columns, 'row mb-3 details');

        this.builder.showContainer();
    }
}

Step 5: Creating Workers to pass results to be printed.

The orders worker we have shown you already in step 2

Step 6: Printing the results in a readable format.

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.

Step 7: Updating the html to include our new JavaScript files.

<script src="connection_management/connection-status-change-listener.js"></script>
<script src="orders/order-change-listener.js"></script>
<script src="orders/order-state-listener.js"></script>
<script src="orders/order-table-builder.js"></script>
<script src="orders/order-worker.js"></script>
<script src="orders/place-close-order-action.js"></script>
<script src="positions/open-position-change-listener.js"></script>
<script src="positions/open-position-change-listener.js"></script>
<script src="common/table-builder.js"></script>
<script src="index.js"></script>

Step 8: The main JavaScript file.

const sessionFactory = FXConnectLite.FXConnectLiteSessionFactory;
const LoggerFactory = FXConnectLite.LoggerFactory;

function getOpenPositionManager(session, ordersManager) {
    let openPositionManager = session.getOpenPositionsManager();
    let openPositionChangeListener = new OpenPositionChangeListener(ordersManager);

    openPositionManager.subscribeOpenPositionChange(openPositionChangeListener);

    return openPositionManager;
}

function getOrdersManager(session, instrumentsManager, orderWorker) {
    let ordersManager = session.getOrdersManager();
    let orderChangeListener = new OrderChangeListener(ordersManager, orderWorker);
    ordersManager.subscribeOrderChange(orderChangeListener);
    ordersManager.subscribeStateChange(new OrderStateListener(instrumentsManager, ordersManager, orderWorker));

    return ordersManager;
}

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

    let accountCommissionsManager = session.getAccountCommissionsManager();
    let instrumentsManager = session.getInstrumentsManager();
    let offersManager = session.getOffersManager();

    let orderWorker = new OrderWorker(session, accountCommissionsManager, offersManager);
    let ordersManager = getOrdersManager(session, instrumentsManager, orderWorker);

    let openPositionManager = getOpenPositionManager(session, ordersManager, orderWorker);

    let connectionStatusChangeListener = new ConnectionStatusChangeListener(
        session, 
        accountCommissionsManager, 
        instrumentsManager, 
        offersManager, 
        openPositionManager
    );
    session.subscribeConnectionStatusChange(connectionStatusChangeListener);

    bindConnectionRelatedEvents(session, () => openPositionManager.refresh());
});

See also createEntryOrder

When the order is created, you can:

1. Get available instruments.
2. Subscribe and Unsubscribe to instruments.
3. Get price updates for an instrument.
4. Get historical prices for an instrument.
5. Get open positions.

Conclusion

In this article, you learned how to create an entry order using the FCLite API. An entry order is a type of order that is executed when the market price reaches a specified level. You learned how to create an EntryOrderFactory object, which is a helper class that helps you set up the order parameters. You also learned how to create an entry order request, which is an object that contains all the information needed to place the order. Finally, you learned how to use the ordersManager object to send the request to the FCLite server. You can use entry orders to enter a trade at a favorable price or to set a stop-loss or take-profit for an existing trade. You can also modify or cancel your entry orders using similar methods. To learn more about the FCLite API and its features, you can refer to this official documentation.

Download the sample Node TypeScript, Node JavaScript, JavaScript.

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