TradingClient.cpp

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable OnixS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/
#include <OnixS/ICE/BOE/IceBoe.h>
 
#include <Settings/Defaults.h>
#include <Common/Tools.h>
#include <Common/Helpers.h>
#include "Utils.h"
 
#include "TradingClient.h"
 
namespace Samples {
 
using namespace ONIXS_ICEBOE_NAMESPACE;
using namespace ONIXS_ICEBOE_MESSAGING_NAMESPACE;
using namespace CUI;
 
namespace {
 
void checkSettingSanity(const Settings& settings)
{
    const auto traderId = settings.get("TraderId");
    const auto traderPwd = settings.get("TraderPwd");
    const auto clientId = settings.get<Int32>("ClientId");
    const auto userId = settings.get("UserId");
    const auto userPwd = settings.get("Password");
    const auto host = settings.get("Host");
    const auto port = settings.get<Port>("Port");
    const auto onBehalfOfSubId = settings.get("OnBehalfOfSubId");
    const auto onBehalfOfLocationId = settings.get("OnBehalfOfLocationId");
    const auto onBehalfOfCompId = settings.get("OnBehalfOfCompId");
    const auto clearingFirm = settings.get<Int32>("ClearingFirm");
    const auto clearingAccount = settings.get("ClearingAccount");
    const auto mifidId = settings.get<Int64>("MifidId");
    const auto keepAliveInterval = settings.get<UInt16>("KeepAliveInterval");
    const auto investmentDecision = settings.get<Int64>("InvestmentDecision");
    const auto executionDecision = settings.get<Int64>("ExecutionDecision");
 
    ignoreUnusedVariableWarning(
        traderId
        ,traderPwd
        ,clientId
        ,userId
        ,userPwd
        ,host
        ,port
        ,onBehalfOfSubId
        ,onBehalfOfLocationId
        ,onBehalfOfCompId
        ,clearingFirm
        ,clearingAccount
        ,mifidId
        ,keepAliveInterval
        ,investmentDecision
        ,executionDecision
    );
}
 
SessionSettings fillSessionSettings(const Settings& settings)
{
    checkSettingSanity(settings);
 
    SessionSettings sessionSettings;
 
    sessionSettings
        .licenseStore("../../license")
        .userId(settings.get("UserId"))
        .clientId(settings.get<Int32>("ClientId"))
        .rawData(settings.get("Password"))
        .reconnectAttempts(100)
        .reconnectInterval(1)
        .keepAliveInterval(settings.get<UInt16>("KeepAliveInterval"))
        .useTLS(settings.get<Port>("Port") == Default::TlsPort)
        ;
 
    return sessionSettings;
}
 
auto initSecurityDefinitionRequest(const Settings&)
{
    SecurityDefinitionRequestMsg request;
    return request;
}
 
auto initNewOrder(const Settings& settings)
{
    NewOrderRequestMsg request;
 
    request->
        originatorUserId(settings.get("TraderId"))
        .onBehalfOfSubId(settings.get("OnBehalfOfSubId"))
        .onBehalfOfLocationId(settings.get("OnBehalfOfLocationId"))
        .onBehalfOfCompId(settings.get("OnBehalfOfCompId"))
        .clearingFirm(settings.get<Int32>("ClearingFirm"))
        .clearingAccount(settings.get("ClearingAccount"))
        .mifidId(settings.get<Int64NULL>("MifidId"))
        .manualOrderIndicator(BooleanEnum::True)
        .custOrderHandlingInst(CustOrderHandlingInstEnum::Y)
        .memo("NewOrderRequest")
        .selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum::CancelTakingOrder);
 
    if(settings.isSet("SelfMatchPreventionId"))
        request->selfMatchPreventionId(settings.get<Int64>("SelfMatchPreventionId"));
 
    return request;
}
 
auto initOrderCancelRequest(const Settings& settings)
{
    CancelRequestMsg request;
 
    request->originatorUserId(settings.get("TraderId"));
 
    return request;
}
 
auto initOrderReplaceRequest(const Settings& settings)
{
    CancelReplaceRequestMsg request;
 
    request->
         originatorUserId(settings.get("TraderId"))
        .onBehalfOfSubId(settings.get("OnBehalfOfSubId"))
        .onBehalfOfLocationId(settings.get("OnBehalfOfLocationId"))
        .onBehalfOfCompId(settings.get("OnBehalfOfCompId"))
        .clearingFirm(settings.get<Int32>("ClearingFirm"))
        .clearingAccount(settings.get("ClearingAccount"))
        .mifidId(settings.get<Int64NULL>("MifidId"))
        .manualOrderIndicator(BooleanEnum::True)
        .memo("CancelReplaceRequest")
        .selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum::CancelTakingOrder);
 
    if(settings.isSet("SelfMatchPreventionId"))
        request->selfMatchPreventionId(settings.get<Int64>("SelfMatchPreventionId"));
 
    return request;
}
 
auto initNewOrderCrossRequest(const Settings& settings)
{
    NewOrderCrossRequestMsg request;
 
    const auto onBehalfOfSubId = settings.get("OnBehalfOfSubId");
    const auto onBehalfOfLocationId = settings.get("OnBehalfOfLocationId");
    const auto onBehalfOfCompId = settings.get("OnBehalfOfCompId");
    const auto clearingFirm = settings.get<Int32>("ClearingFirm");
    const auto clearingAccount = settings.get("ClearingAccount");
    const auto mifidId = settings.get<Int64NULL>("MifidId");
 
    request->originatorUserId(settings.get("TraderId"));
    request->crossType(CrossTypeEnum::IOC);
 
    auto sides = request->sides(2);
 
    sides[0]
        .onBehalfOfSubId(onBehalfOfSubId)
        .onBehalfOfLocationId(onBehalfOfLocationId)
        .onBehalfOfCompId(onBehalfOfCompId)
        .clearingFirm(clearingFirm)
        .clearingAccount(clearingAccount)
        .mifidId(mifidId)
        .manualOrderIndicator(BooleanEnum::True)
        .memo("NewOrderCrossRequest[0]")
        .custOrderHandlingInst(CustOrderHandlingInstEnum::Y)
        .selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum::CancelTakingOrder);
 
    sides[1]
        .onBehalfOfSubId(onBehalfOfSubId)
        .onBehalfOfLocationId(onBehalfOfLocationId)
        .onBehalfOfCompId(onBehalfOfCompId)
        .clearingFirm(clearingFirm)
        .clearingAccount(clearingAccount)
        .mifidId(mifidId)
        .manualOrderIndicator(BooleanEnum::True)
        .memo("NewOrderCrossRequest[1]")
        .custOrderHandlingInst(CustOrderHandlingInstEnum::Y)
        .selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum::CancelTakingOrder);
 
    if(settings.isSet("SelfMatchPreventionId"))
    {
        const auto id = settings.get<Int64>("SelfMatchPreventionId");
        sides[0].selfMatchPreventionId(id);
        sides[1].selfMatchPreventionId(id);
    }
 
    return request;
}
 
auto initOrderMassCancelRequest(const Settings& settings)
{
    OrderMassCancelRequestMsg request;
 
    request->originatorUserId(settings.get("TraderId"));
    request->massCancelRequestType(MassCancelRequestTypeEnum::CancelAllForTrader);
 
    return request;
}
 
auto initQuoteRequest(const Settings& settings)
{
    QuoteRequestMsg request;
 
    request->
         originatorUserId(settings.get("TraderId"))
        .onBehalfOfSubId(settings.get("OnBehalfOfSubId"))
        .onBehalfOfLocationId(settings.get("OnBehalfOfLocationId"))
        .onBehalfOfCompId(settings.get("OnBehalfOfCompId"))
        .clearingFirm(settings.get<Int32>("ClearingFirm"))
        .clearingAccount(settings.get("ClearingAccount"));
 
    return request;
}
 
auto initQuoteCancelRequest(const Settings& settings)
{
    QuoteCancelRequestMsg request;
 
    request->originatorUserId(settings.get("TraderId"));
    request->quoteCancelType(QuoteCancelTypeEnum::CancelByUnderlyingMarket);
    request->quoteEntries(1);
 
    return request;
}
 
auto initMassQuoteRequest(const Settings& settings)
{
    MassQuoteRequestMsg request;
 
    request->
        mifidId(settings.get<Int64NULL>("MifidId"))
        .selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum::CancelTakingOrder)
        .riskProtectionReset(BooleanEnum::True)
        .directElectronicAccess(BooleanEnum::True)
        .originatorUserId(settings.get("TraderId"))
    ;
 
    if(settings.isSet("SelfMatchPreventionId"))
        request->selfMatchPreventionId(settings.get<Int64>("SelfMatchPreventionId"));
 
    request->quoteSets(MassQuoteRequestMaxEntriesCount);
    return request;
}
 
 
auto queryString(const char* name, const std::string& defaultValue)
{
    Screen::out("Enter ", name, " (default=", defaultValue, "): ");
    return Screen::getInput(defaultValue);
}
 
auto queryTimestamp(const char* name, Timestamp defaultValue)
{
    Screen::out("Enter ", name, " (default=", toStr(defaultValue, TimestampFormat::YYYYMMDD), "): ");
    const auto userInput = Screen::getInput<std::string>();
 
    if(userInput.empty())
        return defaultValue;
 
    return Timestamp::fromStr(userInput, TimestampFormat::YYYYMMDD);
}
 
template <typename OptionalType>
auto queryOptionalTimestamp(const char* name, OptionalType defaultValue = {})
{
    Screen::out("Enter ", name, ", optional, (default=", defaultValue ? toStr(*defaultValue, TimestampFormat::YYYYMMDD) : toStr(nullOpt), "): ");
    const auto userInput = Screen::getInput<std::string>();
 
    if(userInput.empty())
        return defaultValue;
 
    if(userInput == toStr(nullOpt))
        return OptionalType{};
 
    return OptionalType{Timestamp::fromStr(userInput, TimestampFormat::YYYYMMDD)};
}
 
template <typename T>
auto queryNumeric(const char* name, T defaultValue, typename std::enable_if<std::is_integral<T>::value, void*>::type = nullptr)
{
    Screen::out("Enter ", name, " (default=", toStr(defaultValue), "): ");
    return Screen::getInput<T>(defaultValue);
}
 
template <typename OptionalType>
auto queryOptionalNumeric(const char* name, typename std::enable_if<isOptional<OptionalType>::value && std::is_integral<typename OptionalType::HeldType>::value, void*>::type = nullptr)
{
    Screen::out("Enter ", name, ", optional, (default=", toStr(nullOpt), "): ");
 
    const auto userInput = Screen::getInput(toStr(nullOpt));
 
    if(userInput.empty() || userInput == toStr(nullOpt))
        return OptionalType{};
 
    return OptionalType{parseUserInput<typename OptionalType::HeldType>(userInput)};
}
 
auto queryDecimal(const char* name, Decimal9 defaultValue)
{
    Screen::out("Enter ", name, " (default=", toStr(Decimal{defaultValue, -9}), "): ");
    const auto userInput = Screen::getInput<std::string>();
 
    if(userInput.empty())
        return defaultValue;
 
    return toPriceMantissa(parseUserInput<double>(userInput));
}
 
template <typename OptionalType>
auto queryOptionalDecimal(const char* name, OptionalType defaultValue = {}, typename std::enable_if<isOptional<OptionalType>::value, void*>::type=nullptr)
{
    Screen::out("Enter ", name, ", optional, (default=", toStr(defaultValue), "): ");
 
    const auto userInput = Screen::getInput(toStr(defaultValue));
 
    if(userInput.empty())
        return defaultValue;
 
    if(userInput == toStr(nullOpt))
        return OptionalType{};
 
    return OptionalType{toPriceMantissa(parseUserInput<double>(userInput))};
}
 
template<typename Type, size_t Size>
auto queryEnum(const char* name, const Type (&allowedValues)[Size], Type defaultValue, typename std::enable_if<isScopedEnum<Type>::value, void*>::type=nullptr)
{
    const std::set<Type> val{std::begin(allowedValues), std::end(allowedValues)};
    Screen::out("Enter ", name, " [", join(val.begin(), val.end(), ','), "] (default=", toStr(defaultValue), "):");
 
    const auto userInput = Screen::getInput<std::string>();
 
    if(userInput.empty())
        return defaultValue;
 
    const auto value = parseUserInput<Type>(userInput);
 
    if(val.find(value) == val.end())
        throw std::invalid_argument("Invalid user input: '" + toStr(value) + "'");
 
    return value;
}
 
template<typename OptionalType, size_t Size>
auto queryOptionalEnum(const char* name, const typename OptionalType::HeldType (&allowedValues)[Size], OptionalType defaultValue = {}, typename std::enable_if<isOptional<OptionalType>::value && isScopedEnum<typename OptionalType::HeldType>::value, void*>::type=nullptr)
{
    const std::set<typename OptionalType::HeldType> val{std::begin(allowedValues), std::end(allowedValues)};
    Screen::out("Enter ", name, " [", join(val.begin(), val.end(), ','), "], optional, (default=", toStr(nullOpt), "):");
 
    const auto userInput = Screen::getInput<std::string>();
 
    if(userInput.empty())
        return defaultValue;
 
    if(userInput == toStr(nullOpt))
        return OptionalType{};
 
    const auto value = parseUserInput<typename OptionalType::HeldType>(userInput);
 
    return OptionalType{value};
}
 
template<size_t Size>
auto querySide(const SideEnum (&allowedValues)[Size], SideEnum defaultValue = Default::Side)
{
    return queryEnum("Side", allowedValues, defaultValue);
}
 
template<typename OptionalType, size_t Size>
auto querySideOptional(const SideEnum (&allowedValues)[Size])
{
    return queryOptionalEnum<OptionalType>("Side", allowedValues);
}
 
template<size_t Size>
auto queryOrderType(const OrderTypeEnum (&allowedValues)[Size], OrderTypeEnum defaultValue = OrderTypeEnum::Limit)
{
    return queryEnum("OrderType", allowedValues, defaultValue);
}
 
template<typename OptionalType, size_t Size>
auto queryOrderTypeOptional(const typename OptionalType::HeldType (&allowedValues)[Size])
{
     return queryOptionalEnum<OptionalType, Size>("OrderType", allowedValues);
}
 
template<size_t Size>
auto queryTimeInForce(const TimeInForceEnum (&allowedValues)[Size], TimeInForceEnum defaultValue = TimeInForceEnum::Day)
{
    return queryEnum("TimeInForce", allowedValues, defaultValue);
}
 
template<typename OptionalType, size_t Size>
auto queryTimeInForceOptional(const TimeInForceEnum (&allowedValues)[Size])
{
    return queryOptionalEnum<OptionalType, Size>("TimeInForce", allowedValues);
}
 
template<size_t Size>
auto querySecurityRequestType(const SecurityRequestTypeEnum (&allowedValues)[Size], SecurityRequestTypeEnum defaultValue = SecurityRequestTypeEnum::RequestListofOptions)
{
    return queryEnum("SecurityRequestType", allowedValues, defaultValue);
}
 
template<typename OptionalType, size_t Size>
auto queryPriceTypeOptional(const typename OptionalType::HeldType (&allowedValues)[Size])
{
    return queryOptionalEnum<OptionalType, Size>("PriceType", allowedValues);
}
 
template<typename OptionalType, size_t Size>
auto queryBenchmarkPriceTypeOptional(const typename OptionalType::HeldType (&allowedValues)[Size])
{
    return queryOptionalEnum<OptionalType, Size>("BenchmarkPriceType", allowedValues);
}
 
template<typename OptionalType, size_t Size>
auto queryExecInstOptional(const typename OptionalType::HeldType (&allowedValues)[Size], OptionalType defaultValue)
{
    return queryOptionalEnum<OptionalType, Size>("ExecInst", allowedValues, defaultValue);
}
 
template<typename OptionalType, size_t Size>
auto queryBooleanOptional(const char* name, const BooleanEnum (&allowedValues)[Size])
{
    return queryOptionalEnum<OptionalType>(name, allowedValues);
}
 
template<size_t Size>
auto queryCustOrderHandlingInst(const CustOrderHandlingInstEnum (&allowedValues)[Size], CustOrderHandlingInstEnum defaultValue = CustOrderHandlingInstEnum::Y)
{
    return queryEnum("CustOrderHandlingInst", allowedValues, defaultValue);
}
 
struct QuoteIdGenerator
{
    static Int64 id()
    {
        return static_cast<Int64>(UtcWatch::now().sinceEpoch() / TimeTraits::nanosecondsPerSecond());
    }
};
 
}
 
void TradingClient::checkConnected(const SessionPtr& sn, const char* kind)
{
    const bool connected = sn && sn->state() == SessionStateId::Established;
 
    if(!connected)
        throw std::runtime_error("A " + std::string(kind) + " session must be in the [Established] state");
}
 
TradingClient::TradingClient(const Settings& settings)
    : settings_(settings)
    , sessionSettings_(fillSessionSettings(settings_))
    , newOrderRequest_(initNewOrder(settings))
    , securityDefinitionRequest_(initSecurityDefinitionRequest(settings))
    , cancelRequest_(initOrderCancelRequest(settings))
    , replaceRequest_(initOrderReplaceRequest(settings))
    , newOrderCrossRequest_(initNewOrderCrossRequest(settings))
    , orderMassCancelRequest_(initOrderMassCancelRequest(settings))
    , quoteRequest_(initQuoteRequest(settings))
    , quoteCancelRequest_(initQuoteCancelRequest(settings))
    , massQuoteRequest_(initMassQuoteRequest(settings))
{
}
 
OptionalRef<Order> TradingClient::findByOrderId(OrderId orderId)
{
    auto ord = orderBook_.find(orderId);
 
    if (!ord)
         CUI::Screen::warning("No order with id=", orderId, " is found");
 
    return ord;
}
 
void TradingClient::connectBus()
{
    auto settings = sessionSettings_;
 
    if(!busSession_)
        busSession_.reset(new Session(SessionType::BUS, settings, this));
 
    busSession_->connect(settings_.get("Host"), settings_.get<Port>("Port"));
}
 
void TradingClient::requestBgwCredentials()
{
    checkConnected(busSession_, "BUS");
 
    const auto userId = settings_.get("UserId");
 
    MessageHolder<IPRequest, getMaxMessageSize<IPRequest>(1)> request;
    request->clientId(sessionSettings_.clientId());
    request->users(1)[0].userId(userId);
 
    bgwCredentials_ = {};
    TradingClient::send(busSession_, request);
}
 
void TradingClient::requestInstruments()
{
    checkConnected(busSession_, "BUS");
 
    const auto marketTypeId = queryNumeric("MarketTypeId", Default::MarketTypeId);
    const auto requestType = querySecurityRequestType(
            {SecurityRequestTypeEnum::RequestListofOptions,
             SecurityRequestTypeEnum::RequestListofStrategies,
             SecurityRequestTypeEnum::RequestListofFutures,
             SecurityRequestTypeEnum::RequestListOfProducts
            });
 
    MessageHolder<SecurityDefinitionRequest> request;
    request->marketTypeId(marketTypeId);
    request->securityReqId(static_cast<Int32>(IdGenerator::newId() & 0xFFFFFFFFull));
    request->securityRequestType(requestType);
 
    instruments_.clear();
    send(busSession_, request);
}
 
void TradingClient::listInstruments()
{
    std::vector<Messaging::SbeMessage> messages;
 
    for (auto element : instruments_)
        messages.push_back(Messaging::SbeMessage{element->data(), static_cast<Messaging::SbeMessage::EncodedLength>(element->size())});
 
    std::reverse(messages.begin(), messages.end());
 
    ListViewer::outputItems(messages, [](auto msg)
    {
        std::string res;
 
        if(!ONIXS_ICEBOE_MESSAGING_NAMESPACE::processTypified(msg, [&](const auto msg) { toStr(res, msg); }))
            res = "[]";
 
        return res;
    }, 10);
}
 
void TradingClient::lookupInstruments()
{
    const auto symbol = queryNumeric("Symbol", Default::Symbol);
 
    std::vector<Messaging::SecurityDefinitionReport> messages;
 
    for (auto element : instruments_)
    {
        const Messaging::SecurityDefinitionReport msg{element->data(), static_cast<Messaging::SbeMessage::EncodedLength>(element->size())};
 
        if(msg.symbol() == symbol)
            messages.push_back(msg);
    }
 
    ListViewer::outputItems(messages, [](auto msg){return toStr(msg);}, 10);
}
 
void TradingClient::connectBgw()
{
    if(!bgwCredentials_)
        throw std::runtime_error("BGW credentials must be obtained first");
 
    auto settings = sessionSettings_;
 
    if(!bgwSession_)
        bgwSession_.reset(new Session(SessionType::BGW, settings, this));
 
    bgwSession_->connect(bgwCredentials_.host(), bgwCredentials_.port(), bgwCredentials_.ipSessionToken());
}
 
void TradingClient::traderLogon()
{
    checkConnected(bgwSession_, "BGW");
 
    MessageHolder<TraderLogonRequest> request;
    request->originatorUserId(settings_.get("TraderId"));
    request->rawData(settings_.get("TraderPwd"));
    request->directElectronicAccess(BooleanEnum::True);
    request->tradingCapacity(TradingCapacityEnum::DEAL);
    request->liquidityProvision(BooleanEnum::True);
    request->commodityDerivIndicator(BooleanEnum::False);
    request->investmentDecision(settings_.get<Int64>("InvestmentDecision"));
    request->executionDecision(settings_.get<Int64>("ExecutionDecision"));
 
    TradingClient::send(bgwSession_, request);
}
 
void TradingClient::traderLogout()
{
    checkConnected(bgwSession_, "BGW");
 
    MessageHolder<TraderLogoutRequest> request;
    request->originatorUserId(settings_.get("TraderId"));
 
    TradingClient::send(bgwSession_, request);
}
 
void TradingClient::sendOrder()
{
    checkConnected(bgwSession_, "BGW");
 
    const auto order = orderBook_.store(newOrder());
    Screen::info(order.toString());
 
    newOrderRequest_->price(order.price_.raw())
        .orderQty(order.orderQty_)
        .symbol(order.securityId_)
        .clOrdId(order.cIOrdId_)
        .stopPx(order.stopPx_.raw())
        .ordType(order.ordType_)
        .timeInForce(order.timeInForce_)
        .side(order.side_)
        .maxShow(order.maxShow_.raw())
        .execInst(order.execInst_.raw())
        ;
 
    if (order.timeInForce_ == TimeInForceEnum::GTD && order.expireDate_)
        newOrderRequest_->expireDate(*order.expireDate_);
    else
        newOrderRequest_->expireDate(nullOpt);
 
    const auto custOrderHandlingInst =
        queryCustOrderHandlingInst({
            CustOrderHandlingInstEnum::C
            ,CustOrderHandlingInstEnum::D
            ,CustOrderHandlingInstEnum::G
            ,CustOrderHandlingInstEnum::H
            ,CustOrderHandlingInstEnum::W
            ,CustOrderHandlingInstEnum::Y
        });
 
    newOrderRequest_->custOrderHandlingInst(custOrderHandlingInst);
 
    const auto selfMatchPreventionInstruction =
        queryOptionalEnum<decltype(std::declval<const NewOrderRequest&>().selfMatchPreventionInstruction())>(
        "SelfMatchPreventionInstruction",
        {
            SelfMatchPreventionInstructionEnum::CancelRestingOrder
            ,SelfMatchPreventionInstructionEnum::CancelTakingOrder
            ,SelfMatchPreventionInstructionEnum::CancelBothOrders
        });
 
    newOrderRequest_->selfMatchPreventionInstruction(selfMatchPreventionInstruction.raw());
 
    TradingClient::send(bgwSession_, newOrderRequest_);
}
 
void TradingClient::sendOrderCross()
{
    checkConnected(bgwSession_, "BGW");
 
    const auto transactDetails = queryString("TransactDetails", "***");
 
    const auto priceType =
        queryPriceTypeOptional<decltype(std::declval<const NewOrderCrossRequest&>().priceType())>({
            PriceTypeEnum::PerContract,
            PriceTypeEnum::FixedCabinetTradePrice,
            PriceTypeEnum::FixedRate,
            PriceTypeEnum::NPV,
            PriceTypeEnum::RateDifferential,
            PriceTypeEnum::NPVDifferential});
 
    const auto benchmarkPriceType =
            queryBenchmarkPriceTypeOptional<decltype(std::declval<const NewOrderCrossRequest&>().benchMarkPriceType())>({
                BenchmarkPriceTypeEnum::FixedAmount});
 
    const auto bmPrice =
            queryOptionalDecimal<decltype(std::declval<const NewOrderCrossRequest&>().benchmarkPrice())>("BenchmarkPrice");
 
    const auto crossType = queryEnum("CrossType", {CrossTypeEnum::AON, CrossTypeEnum::IOC}, CrossTypeEnum::AON);
 
    const auto custOrderHandlingInst =
            queryCustOrderHandlingInst({
                CustOrderHandlingInstEnum::C
                ,CustOrderHandlingInstEnum::D
                ,CustOrderHandlingInstEnum::G
                ,CustOrderHandlingInstEnum::H
                ,CustOrderHandlingInstEnum::W
                ,CustOrderHandlingInstEnum::Y
            });
 
    newOrderCrossRequest_->priceType(priceType.raw());
    newOrderCrossRequest_->benchMarkPriceType(benchmarkPriceType.raw());
    newOrderCrossRequest_->benchmarkPrice(bmPrice.raw());
    newOrderCrossRequest_->transactDetails(toStrRef(transactDetails));
    newOrderCrossRequest_->crossType(crossType);
 
    auto crossOrder = orderBook_.store(newOrderCross());
 
    Screen::info(crossOrder.toString());
 
    const auto& buySideOrder = *crossOrder.buySideOrder_;
    const auto& sellSideOrder = *crossOrder.sellSideOrder_;
 
    auto sides = newOrderCrossRequest_->sides();
    assert(sides.size() == 2);
 
    newOrderCrossRequest_->crossId(crossOrder.id());
 
    newOrderCrossRequest_->price(buySideOrder.price_.raw())
        .orderQty(buySideOrder.orderQty_)
        .symbol(buySideOrder.securityId_)
        .ordType(buySideOrder.ordType_)
        .timeInForce(buySideOrder.timeInForce_);
 
    sides[0].side(buySideOrder.side_);
    sides[0].clOrdId(buySideOrder.cIOrdId_);
    sides[0].custOrderHandlingInst(custOrderHandlingInst);
 
    sides[1].side(sellSideOrder.side_);
    sides[1].clOrdId(sellSideOrder.cIOrdId_);
    sides[1].custOrderHandlingInst(custOrderHandlingInst);
 
    newOrderCrossRequest_->transactTime(UtcWatch::now());
 
    TradingClient::send(bgwSession_, newOrderCrossRequest_);
}
 
void TradingClient::sendMassCancel()
{
    checkConnected(bgwSession_, "BGW");
 
    orderMassCancelRequest_->clOrdId(IdGenerator::newId());
 
    const auto requestType = queryEnum(
        "RequestType", {MassCancelRequestTypeEnum::CancelAllForTrader, MassCancelRequestTypeEnum::CancelForTradingSession}, MassCancelRequestTypeEnum::CancelAllForTrader);
 
    const auto ordType = queryOrderTypeOptional<decltype(std::declval<const OrderMassCancelRequest&>().ordType())>(
        {OrderTypeEnum::Limit});
 
    const auto side = querySideOptional<decltype(std::declval<const OrderMassCancelRequest&>().side())>(
        {SideEnum::Buy, SideEnum::Sell});
 
    const auto symbol = queryOptionalNumeric<decltype(std::declval<const OrderMassCancelRequest&>().symbol())>("Symbol");
 
    const auto marketTypeId = queryOptionalNumeric<decltype(std::declval<const OrderMassCancelRequest&>().marketTypeId())>("MarketTypeId");
 
    const auto price = queryOptionalDecimal<decltype(std::declval<const OrderMassCancelRequest&>().price())>("Price");
 
    const auto timeInForce = queryTimeInForceOptional<decltype(std::declval<const OrderMassCancelRequest&>().timeInForce())>({TimeInForceEnum::Day});
 
    const auto onBehalfOfSubId = queryString("OnBehalfOfSubId", "");
 
    orderMassCancelRequest_->massCancelRequestType(requestType);
    orderMassCancelRequest_->ordType(ordType.raw());
    orderMassCancelRequest_->side(side.raw());
    orderMassCancelRequest_->symbol(symbol.raw());
    orderMassCancelRequest_->marketTypeId(marketTypeId.raw());
    orderMassCancelRequest_->price(price.raw());
    orderMassCancelRequest_->timeInForce(timeInForce.raw());
    orderMassCancelRequest_->onBehalfOfSubId(toStrRef(onBehalfOfSubId));
 
    TradingClient::send(bgwSession_, orderMassCancelRequest_);
}
 
void TradingClient::sendQuote()
{
    checkConnected(bgwSession_, "BGW");
 
    const auto qti = queryDecimal("Quantity", Default::QuantityMantissa);
    const auto side = querySide({SideEnum::Buy, SideEnum::Sell});
    const auto symbol = queryNumeric("Symbol", Default::Symbol);
 
    quoteRequest_
        ->rfqReqId(IdGenerator::newId())
        .orderQty(qti)
        .side(side)
        .symbol(symbol);
 
    TradingClient::send(bgwSession_, quoteRequest_);
}
 
Int32 TradingClient::getQuoteSetId(Int32 underlyingSymbol)
{
    for(auto&& pair : quoteSetId_)
    {
        if(pair.second == underlyingSymbol)
            return pair.first;
    }
 
    quoteSetId_.emplace_back(static_cast<Int32>(quoteSetId_.size() + 1), underlyingSymbol);
    return quoteSetId_.back().first;
}
 
void TradingClient::sendMassQuote()
{
    checkConnected(bgwSession_, "BGW");
 
    massQuoteRequest_->quoteId(QuoteIdGenerator::id());
 
    const auto riskProtectionReset =
    queryBooleanOptional<decltype(std::declval<const MassQuoteRequest&>().riskProtectionReset())>(
            "RiskProtectionReset", {BooleanEnum::False, BooleanEnum::True});
 
    massQuoteRequest_->riskProtectionReset(riskProtectionReset.raw());
 
    const auto quotes = massQuoteRequest_->quoteSets();
 
    for(auto&& quote : quotes)
    {
        const auto underlyingSymbol = queryNumeric("Underlying Symbol", Default::UnderlyingSymbol);
 
        quote
            .quoteEntryId(static_cast<Int32>(IdGenerator::newId()))
            .underlyingSymbol(underlyingSymbol)
            .quoteSetId(getQuoteSetId(underlyingSymbol))
            .symbol(queryNumeric("Symbol", Default::Symbol))
            .bidPx(queryDecimal("Bid Price", Default::PriceMantissa))
            .bidSz(queryDecimal("Bid Size", Default::QuantityMantissa))
            .offerPx(queryDecimal("Offer Price", Default::PriceMantissa))
            .offerSz(queryDecimal("Offer Size", Default::QuantityMantissa))
        ;
    }
 
    TradingClient::send(bgwSession_, massQuoteRequest_);
}
 
void TradingClient::sendQuoteCancelRequest()
{
    checkConnected(bgwSession_, "BGW");
 
    quoteCancelRequest_->quoteId(QuoteIdGenerator::id());
    assert(quoteCancelRequest_->quoteEntries().size() == 1);
 
    const auto quoteCancelType = queryEnum("QuoteCancelType",
       { QuoteCancelTypeEnum::CancelAll, QuoteCancelTypeEnum::CancelByProductID, QuoteCancelTypeEnum::CancelByUnderlyingMarket},
       QuoteCancelTypeEnum::CancelByUnderlyingMarket);
 
    quoteCancelRequest_->quoteCancelType(quoteCancelType);
 
    auto entry = quoteCancelRequest_->quoteEntries()[0];
 
    using OptSymbol = decltype(std::declval<const QuoteCancelRequest::QuoteEntry&>().underlyingSymbol());
    const auto underlyingSymbol = queryOptionalNumeric<OptSymbol>("UnderlyingSymbol");
 
    using OptSecId = decltype(std::declval<const QuoteCancelRequest::QuoteEntry&>().underlyingSecurityId());
    const auto secId = queryOptionalNumeric<OptSecId>("SecurityId");
 
    using OptProduct = decltype(std::declval<const QuoteCancelRequest::QuoteEntry&>().underlyingProduct());
    const auto product = queryOptionalNumeric<OptProduct>("Product");
 
    entry.underlyingSymbol(underlyingSymbol.raw());
    entry.underlyingSecurityId(secId.raw());
    entry.underlyingProduct(product.raw());
 
    TradingClient::send(bgwSession_, quoteCancelRequest_);
}
 
void TradingClient::createStrategy()
{
    checkConnected(bgwSession_, "BGW");
 
    constexpr size_t CreateStrategyMaxLegsCount = 5;
 
    MessageHolder<
        SecurityDefinitionRequest_CreateStrategy,
        getMaxMessageSize<SecurityDefinitionRequest_CreateStrategy>(CreateStrategyMaxLegsCount)> msg;
 
    msg->marketTypeId(queryNumeric("MarketTypeId", Default::MarketTypeId));
    msg->securityReqId(static_cast<Int32>(IdGenerator::newId() & 0xFFFFFFFFull));
    msg->securityRequestType(SecurityRequestTypeEnum::CreateStrategy);
    msg->securityType(SecurityTypeEnum::MLEG);
 
    using OptionalDate = decltype(std::declval<const SecurityDefinitionRequest_CreateStrategy&>().startDate());
    const auto startDate = queryOptionalTimestamp<OptionalDate>("StartDate");
    const auto endDate = queryOptionalTimestamp<OptionalDate>("EndDate");
 
    if(startDate)
         msg->startDate(*startDate);
    else
         msg->startDate(nullOpt);
 
    if(endDate)
         msg->endDate(*endDate);
    else
         msg->endDate(nullOpt);
 
    const auto legsCount = queryNumeric("Number of Legs", UInt32{2});
 
    assert(legsCount <= CreateStrategyMaxLegsCount);
 
    assert(std::distance(std::begin(Default::Symbols), std::end(Default::Symbols)) >= legsCount);
    auto defaultSymbol = std::begin(Default::Symbols);
 
    auto legs = msg->legs(legsCount);
 
    for(auto&& leg : legs)
    {
        leg.legSecurityType(SecurityTypeEnum::OPT);
 
        leg.legSymbol(queryNumeric("Symbol", *defaultSymbol));
 
        const auto side = querySide({SideEnum::Buy, SideEnum::Sell});
        leg.legSide(side);
 
        using OptDenominator = decltype(std::declval<const std::decay<decltype(leg)>::type>().legRatioQtyDenominator());
        const auto denominator = queryOptionalNumeric<OptDenominator>("LegRatioQtyDenominator");
 
        using OptNuminator = decltype(std::declval<const std::decay<decltype(leg)>::type>().legRatioQtyNumerator());
        const auto numerator = queryOptionalNumeric<OptNuminator>("LegRatioQtyNumerator");
 
        leg.legRatioQtyDenominator(denominator.raw());
        leg.legRatioQtyNumerator(numerator.raw());
 
        ++defaultSymbol;
    }
 
    TradingClient::send(bgwSession_, msg);
}
 
void TradingClient::createFlex()
{
    checkConnected(bgwSession_, "BGW");
 
    MessageHolder<SecurityDefinitionRequest_CreateFlex> msg;
    msg->securityRequestType(SecurityRequestTypeEnum::CreateFlexOption);
    msg->securityReqId(static_cast<Int32>(IdGenerator::newId()));
 
    const auto marketTypeId = queryNumeric("MarketTypeId", Default::MarketTypeId);
    const auto type = queryEnum("SecurityType", {SecurityTypeEnum::OPT, SecurityTypeEnum::FUT, SecurityTypeEnum::MLEG}, SecurityTypeEnum::OPT);
 
    using OptionalDate = decltype(std::declval<const SecurityDefinitionRequest_CreateFlex&>().maturityDate());
    const auto maturityDate = queryOptionalTimestamp<OptionalDate>("MaturityDate");
 
    using OptionalProductId = decltype(std::declval<const SecurityDefinitionRequest_CreateFlex&>().productId());
    const auto productId = queryOptionalNumeric<OptionalProductId>("ProductId");
 
    using OptionalSymbol = decltype(std::declval<const SecurityDefinitionRequest_CreateFlex&>().symbol());
    const auto symbol = queryOptionalNumeric<OptionalSymbol>("Symbol");
 
    using OptionalPrice = decltype(std::declval<const SecurityDefinitionRequest_CreateFlex&>().strikePrice());
    const auto price = queryOptionalDecimal<OptionalPrice>("StrikePrice");
 
    msg->securityType(type);
    msg->marketTypeId(marketTypeId);
    msg->productId(productId.raw());
    msg->symbol(symbol.raw());
    msg->strikePrice(price.raw());
 
    if(maturityDate)
        msg->maturityDate(*maturityDate);
    else
        msg->maturityDate(nullOpt);
 
    TradingClient::send(bgwSession_, msg);
}
 
CrossOrderPtr TradingClient::newOrderCross()
{
    auto crossOrder = std::make_shared<CrossOrder>();
 
    Order& buySideOrder = *crossOrder->buySideOrder_;
    Order& sellSideOrder = *crossOrder->sellSideOrder_;
 
    const auto symbol = queryNumeric("Symbol", Default::Symbol);
    buySideOrder.securityId_ = symbol;
    sellSideOrder.securityId_ = symbol;
 
    const auto ordType = queryOrderType({OrderTypeEnum::Market, OrderTypeEnum::Limit}, OrderTypeEnum::Limit);
 
    buySideOrder.ordType_ = ordType;
    sellSideOrder.ordType_ = ordType;
 
    if (ordType == OrderTypeEnum::Limit)
    {
        const auto price = queryDecimal("Price", 64570000);
        buySideOrder.price_ = price;
        sellSideOrder.price_ = price;
    }
 
    const auto qti = queryDecimal("Quantity", Default::QuantityMantissa);
    buySideOrder.orderQty_ = qti;
    buySideOrder.leavesQty_ = buySideOrder.orderQty_;
    sellSideOrder.orderQty_ = qti;
    sellSideOrder.leavesQty_ = sellSideOrder.orderQty_;
 
    buySideOrder.timeInForce_ = TimeInForceEnum::FAK;
    sellSideOrder.timeInForce_ = TimeInForceEnum::FAK;
 
    buySideOrder.side_ = SideEnum::Buy;
    sellSideOrder.side_ = SideEnum::Sell;
 
    return crossOrder;
}
 
OrderPtr TradingClient::newOrder(const Order* base)
{
    OrderPtr result = std::make_shared<Order>();
    auto& order = *result;
 
    order.securityId_ = queryNumeric("Symbol", base ? base->securityId_ : Default::Symbol);
 
    order.ordType_ = queryOrderType(
            {OrderTypeEnum::Market, OrderTypeEnum::Limit, OrderTypeEnum::Stop, OrderTypeEnum::StopLimit},
            base ? base->ordType_ : OrderTypeEnum::Limit);
 
    if (order.ordType_ == OrderTypeEnum::Limit || order.ordType_ == OrderTypeEnum::StopLimit)
        order.price_ = queryDecimal("Price", Default::PriceMantissa);
 
    if (order.ordType_ == OrderTypeEnum::StopLimit || order.ordType_ == OrderTypeEnum::Stop)
        order.stopPx_ = queryDecimal("StopPx", Default::PriceMantissa);
 
    order.orderQty_ = queryDecimal("Quantity", Default::QuantityMantissa);
    order.leavesQty_ = order.orderQty_;
 
    order.timeInForce_ = queryTimeInForce(
        {TimeInForceEnum::Day, TimeInForceEnum::GTC, TimeInForceEnum::FAK, TimeInForceEnum::FOK, TimeInForceEnum::GTD},
        base ? base->timeInForce_ : TimeInForceEnum::Day );
 
    if (order.timeInForce_ == TimeInForceEnum::GTD)
        order.expireDate_ = queryTimestamp("ExpireDate", (base && base->expireDate_) ? *base->expireDate_ : Default::Timestamp);
 
    order.side_ = querySide({SideEnum::Buy, SideEnum::Sell}, base ? base->side_ : SideEnum::Buy);
 
    order.execInst_ = queryExecInstOptional({ExecInstEnum::AON}, base ? base->execInst_ : Order::ExecInstOptional{nullOpt});
 
    const auto maxShow =
            queryOptionalDecimal("MaxShow", base ? base->maxShow_ : Order::QtiOptional{nullOpt});
 
    if(maxShow != nullOpt)
    {
        if(*maxShow > order.orderQty_)
            throw std::logic_error("Invalid `MaxShow` for order");
 
        order.maxShow_ = *maxShow;
    }
 
    return result;
}
 
void TradingClient::showOrders()
{
    ListViewer::outputItems(orderBook_.getEntries(), print, 10);
}
 
bool activeOrder(const Order& order) noexcept
{
    return order.orderStatus_ == ExecTypeEnum::New || order.orderStatus_ == ExecTypeEnum::PartialFill || order.orderStatus_ == ExecTypeEnum::Replaced;
}
 
void TradingClient::showActiveOrders()
{
    ListViewer::outputItems(orderBook_.getEntries(activeOrder), print, 10);
}
 
void TradingClient::cancelOrder()
{
    checkConnected(bgwSession_, "BGW");
 
    const auto ordersInBook = orderBook_.getEntries(activeOrder);
 
    if (ordersInBook.empty())
    {
        Screen::warning("No active orders found");
        return;
    }
 
    ListViewer::outputItems(ordersInBook, print);
 
    Screen::out("Enter the index of the order to be canceled");
 
    const auto orderIndex = Screen::getInput<size_t>();
    const Order& order = *ordersInBook.at(orderIndex - 1);
 
    cancelRequest_->
        clOrdId(IdGenerator::newId())
        .origClOrdId(order.cIOrdId_)
        .symbol(order.securityId_)
        .side(order.side_)
        ;
 
    TradingClient::send(bgwSession_, cancelRequest_);
}
 
void TradingClient::replaceOrder()
{
    checkConnected(bgwSession_, "BGW");
 
    const auto ordersInBook = orderBook_.getEntries(activeOrder);
 
    if (ordersInBook.empty())
    {
        Screen::warning("No active orders found");
        return;
    }
 
    ListViewer::outputItems(ordersInBook, print);
 
    Screen::out("Enter the index of the order to be replaced");
 
    const auto orderIndex = Screen::getInput<size_t>();
    const auto order = ordersInBook.at(orderIndex - 1);
 
    auto replaceOrder = orderBook_.store(newOrder(order.get()));
    replaceOrder.origCIOrdId_ = order->cIOrdId_;
 
    Screen::info(replaceOrder.toString());
 
    replaceRequest_->price(replaceOrder.price_.raw())
        .orderQty(replaceOrder.orderQty_)
        .symbol(replaceOrder.securityId_)
        .clOrdId(replaceOrder.cIOrdId_)
        .stopPx(replaceOrder.stopPx_.raw())
        .ordType(replaceOrder.ordType_)
        .timeInForce(replaceOrder.timeInForce_)
        .side(replaceOrder.side_)
        .origClOrdId(replaceOrder.origCIOrdId_)
        .maxShow(replaceOrder.maxShow_.raw());
 
    if (replaceOrder.timeInForce_ == TimeInForceEnum::GTD && replaceOrder.expireDate_)
        replaceRequest_->expireDate(*replaceOrder.expireDate_);
    else
        replaceRequest_->expireDate(nullOpt);
 
    TradingClient::send(bgwSession_, replaceRequest_);
}
 
void TradingClient::onNewOrderCrossReport(const Messaging::NewOrderCrossReport msg, Session* sn)
{
    Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
    if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
        return;
 
    const auto status = msg.rfcStatus();
    if(status == RFCStatusEnum::None || status == RFCStatusEnum::Success)
        return;
 
    const auto crossId = msg.crossId();
    auto crossOrder = orderBook_.findCross(crossId);
 
    if (!crossOrder)
    {
        CUI::Screen::warning("No cross with id=", crossId, " is found");
        return;
    }
 
    auto& buySideOrder = *(crossOrder->get()->buySideOrder_);
    auto& sellSideOrder = *(crossOrder->get()->sellSideOrder_);
 
    if(status == RFCStatusEnum::PartialSuccessBidFailure || status == RFCStatusEnum::Failure)
    {
        buySideOrder.orderStatus_ = ExecTypeEnum::Rejected;
        Screen::info("Order changed: " + buySideOrder.toString());
    }
 
    if(status == RFCStatusEnum::PartialSuccessOfferFailure || status == RFCStatusEnum::Failure)
    {
        sellSideOrder.orderStatus_ = ExecTypeEnum::Rejected;
        Screen::info("Order changed: " + sellSideOrder.toString());
    }
}
 
void TradingClient::onExecutionReport_New(const Messaging::ExecutionReport_New msg, Session* sn)
{
     Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
     if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
         return;
 
    if(auto order = findByOrderId(msg.clOrdId()))
    {
        setOrdStatus(**order, msg, ExecTypeEnum::New);
        setCommonMessageFields(**order, msg);
 
        Screen::info("Order changed: " + order->get()->toString());
    }
}
 
void TradingClient::onExecutionReport_Reject(const Messaging::ExecutionReport_Reject msg, Session* sn)
{
     Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
     if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
         return;
 
    if(msg.rejectResponseTo() == RejectResponseToEnum::NewOrder)
    {
        if(auto order = findByOrderId(msg.clOrdId()))
        {
            setOrdStatus(**order, msg, ExecTypeEnum::Rejected);
            setCommonMessageFields(**order, msg);
 
            Screen::info("Order changed: " + order->get()->toString());
        }
    }
}
 
void TradingClient::onExecutionReport_Cancel(const Messaging::ExecutionReport_Cancel msg, Session* sn)
{
     Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
      if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
         return;
 
    const auto origClOrdId = msg.origClOrdId();
 
    if(origClOrdId != nullOpt)
    {
        if(auto order = findByOrderId(*origClOrdId))
        {
            setOrdStatus(**order, msg, ExecTypeEnum::Cancelled);
            setCommonMessageFields(**order, msg);
 
            Screen::info("Order changed: " + order->get()->toString());
        }
    }
}
 
void TradingClient::onExecutionReport_Modify(const Messaging::ExecutionReport_Modify msg, Session* sn)
{
    Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
    if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
        return;
 
    auto newOrder = findByOrderId(msg.clOrdId());
 
    const auto origClOrdId = msg.origClOrdId();
    auto oldOrder = origClOrdId ? findByOrderId(*origClOrdId) : decltype(findByOrderId(*origClOrdId)){};
 
    if(newOrder)
    {
        setOrdStatus(**newOrder, msg, ExecTypeEnum::New);
        setCommonMessageFields(**newOrder, msg);
 
        if(oldOrder)
            newOrder->get()->origCIOrdId_ = oldOrder->get()->cIOrdId_;
 
        Screen::info("Order changed: " + newOrder->get()->toString());
    }
 
    if(oldOrder)
        oldOrder->get()->orderStatus_ = ExecTypeEnum::Replaced;
}
 
void TradingClient::onExecutionReport_Trade(const Messaging::ExecutionReport_Trade msg, Session* sn)
{
     Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
      if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
         return;
 
    if(auto order = findByOrderId(msg.clOrdId()))
    {
        setOrdStatus(**order, msg, msg.leavesQty() > 0 ? ExecTypeEnum::PartialFill : ExecTypeEnum::Fill);
 
        setCommonMessageFields(**order, msg);
        order->get()->lastPx_ = msg.lastPx();
 
        Screen::info("Order changed: " + order->get()->toString());
    }
}
 
void TradingClient::onExecutionReport_Snapshot(const Messaging::ExecutionReport_Snapshot msg, Session* sn)
{
    Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
    std::shared_ptr<Order> order;
    auto found = findByOrderId(msg.clOrdId());
 
    if(found)
        order = *found;
    else
        order = std::make_shared<Order>();
 
    const auto status = msg.orderStatus();
 
    if(status != nullOpt && (*status == OrderStatusEnum::New || *status == OrderStatusEnum::PartialFill))
    {
        if(*status == OrderStatusEnum::New)
            order->orderStatus_ = ExecTypeEnum::New;
        else if(*status == OrderStatusEnum::PartialFill)
            order->orderStatus_ = ExecTypeEnum::PartialFill;
 
        order->cIOrdId_ = msg.clOrdId();
        order->price_ = msg.price();
        order->orderQty_ = msg.leavesQty();
        order->leavesQty_ = msg.leavesQty();
        order->securityId_ = msg.symbol();
        order->side_ = msg.side();
        order->ordType_ = msg.ordType();
        order->stopPx_ = msg.stopPx();
        order->timeInForce_ = msg.timeInForce();
        order->expireDate_ = msg.expireDate();
        order->transactTime_ = msg.execId().transactTime();
        order->maxShow_ = msg.maxShow();
        order->execInst_ = msg.execInst();
        order->origCIOrdId_ = msg.clOrdId();
 
        if(!found)
            orderBook_.store(order);
    }
}
 
void TradingClient::onIPReport(const Messaging::IPReport msg, Session* sn)
{
    Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
    try
    {
        const auto users = msg.users();
 
        if(users.empty())
             throw std::runtime_error("'IPReport' message does not contain connectivity information.");
 
        Messaging::IPReport::UsersEntry entry = users[0];
 
        if (!(entry.success() && *entry.success() == Messaging::BooleanEnum::True))
            throw std::runtime_error("IPReport::UsersEntry is invalid: success flag is missing or not set to True.");
 
        if (!entry.ipAddress() || !entry.port() || !entry.ipSessionToken())
            throw std::runtime_error("Invalid 'IPReport::UsersEntry'");
 
        auto credentials = BgwCredentials(Messaging::toStr(*entry.ipAddress()), *entry.port(), Messaging::toStr(*entry.ipSessionToken()));
 
        bgwCredentials_ = credentials;
    }
    catch(std::exception& e)
    {
        Screen::error(e.what());
    }
}
 
void TradingClient::onSecurityDefinitionReport(const Messaging::SecurityDefinitionReport msg, Session* sn)
{
    if(sn == bgwSession_.get())
        Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
    else
        Screen::printProgress(msg.listSeqNo(), msg.rpts());
 
    std::shared_ptr<std::vector<uint8_t>> p(new std::vector<uint8_t>(msg.calculateBinarySize()));
    assert(p->size() == msg.calculateBinarySize());
    std::memcpy(p->data(), msg.binary(), p->size());
 
    instruments_.push_back(p);
}
 
void TradingClient::onSecurityDefinitionReport_Strategy(const Messaging::SecurityDefinitionReport_Strategy msg, Session* sn)
{
    if(sn == bgwSession_.get())
        Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
    else
        Screen::printProgress(msg.listSeqNo(), msg.rpts());
 
    std::shared_ptr<std::vector<uint8_t>> p(new std::vector<uint8_t>(msg.calculateBinarySize()));
    assert(p->size() == msg.calculateBinarySize());
    std::memcpy(p->data(), msg.binary(), p->size());
 
    instruments_.push_back(p);
}
 
void TradingClient::onError(SessionErrorReason::Enum, const std::string & description, Session * sn, Messaging::SbeMessage)
{
    Screen::error("[" + sn->id() + "] error: [", description, "]");
}
 
void TradingClient::onWarning(SessionWarningReason::Enum, const std::string & description, Session * sn, Messaging::SbeMessage)
{
    Screen::warning("[" + sn->id() + "] warning: [", description, "]");
}
 
void TradingClient::onStateChange(SessionStateId::Enum newState, SessionStateId::Enum /*prevState*/, Session * sn)
{
    Screen::trace("[" + sn->id() + "] changed it's state to [", SessionStateId::toString(newState), "]");
}
 
void TradingClient::onMessageSending(char* bytes, size_t size, Session* sn)
{
    const auto msg = SbeMessage(bytes, static_cast<Messaging::MessageSize>(size));
 
    if(msg.templateId() != HeartBeat::TemplateId)
        CUI::Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::Out);
}
 
}