153 lines
4.9 KiB
C++
153 lines
4.9 KiB
C++
#include "SpreaderOrderMan.h"
|
|
|
|
#include "server/sparkd/orderman/spreader_orders/SpreaderOrder.h"
|
|
#include "server/sparkd/orderman/events/CreateSpreaderOrder.h"
|
|
#include "server/sparkd/orderman/events/UpdateSpreaderOrder.h"
|
|
#include "server/sparkd/orderman/events/CancelSpreaderOrder.h"
|
|
#include "server/sparkd/orderman/events/GatewayStatusChange.h"
|
|
#include "server/sparkd/orderman/events/TimeChange.h"
|
|
#include "server/sparkd/orderman/native_orders/NativeOrderHeader.h"
|
|
#include "server/sparkd/orderman/persistence/gen_order_id.h"
|
|
#include "server/sparkd/orderman/events/NativeOrderStateChange.h"
|
|
|
|
#include "lib/logging/logging.h"
|
|
#include "lib/utils/PBUtils.h"
|
|
|
|
namespace bts {
|
|
namespace orderman {
|
|
|
|
using SpreaderOrderPtr = std::unique_ptr<SpreaderOrder>;
|
|
using SpreaderOrderMap = boost::container::flat_map<OrderKey, SpreaderOrderPtr>;
|
|
|
|
struct SpreaderOrderMan::PImpl {
|
|
PImpl(securities::SecurityDB &db,
|
|
NativeOrderFactory &factory) :
|
|
sec_db(db),
|
|
native_order_factory(factory),
|
|
spreader_orders(),
|
|
gateway_ready(false)
|
|
{}
|
|
|
|
securities::SecurityDB &sec_db;
|
|
NativeOrderFactory &native_order_factory;
|
|
SpreaderOrderMap spreader_orders;
|
|
bool gateway_ready;
|
|
};
|
|
|
|
SpreaderOrderMan::SpreaderOrderMan (securities::SecurityDB &sec_db,
|
|
NativeOrderFactory &native_order_factory,
|
|
std::vector<api::orderman::OrderState> const &existing_orders)
|
|
: me(new PImpl(sec_db,native_order_factory))
|
|
{
|
|
for (auto const &os : existing_orders)
|
|
if (os.has_spreader())
|
|
me->spreader_orders[OrderKey(os.order_key()) ] =
|
|
std::make_unique<SpreaderOrder>(sec_db,me->native_order_factory,os);
|
|
}
|
|
|
|
SpreaderOrderMan::~SpreaderOrderMan() {}
|
|
|
|
void SpreaderOrderMan::on(event_grid::event::Init const&)
|
|
{
|
|
LOG(OrderMan,Diag, "SpreaderOrderMan init");
|
|
for (auto const &kvp : me->spreader_orders)
|
|
kvp.second->init();
|
|
}
|
|
|
|
void SpreaderOrderMan::on(event::CreateSpreaderOrder const&cso)
|
|
{
|
|
LOG(OrderMan,Diag, "CreateSpreaderOrder {}: {}",
|
|
cso.order_key.value(),
|
|
utils::pb::to_string(cso.create));
|
|
|
|
auto & order = me->spreader_orders[cso.order_key];
|
|
bts_assert(!order);
|
|
order = std::make_unique<SpreaderOrder> (me->sec_db,
|
|
me->native_order_factory,
|
|
cso.order_key,cso.create);
|
|
order->init();
|
|
if (me->gateway_ready)
|
|
order->on_connect();
|
|
}
|
|
|
|
void SpreaderOrderMan::on(event::UpdateSpreaderOrder const&uso)
|
|
{
|
|
LOG(OrderMan,Diag, "UpdateSpreaderOrder {}: {}",
|
|
uso.order_key.value(),
|
|
utils::pb::to_string(uso.update));
|
|
|
|
auto it = me->spreader_orders.find(uso.order_key);
|
|
if (it != me->spreader_orders.end()) {
|
|
auto &order = *it->second.get();
|
|
order.on_update(uso.update);
|
|
}
|
|
else
|
|
LOG(OrderMan,Error, "Ignoring attempt to update unknown spreader order id {}",
|
|
uso.order_key.value());
|
|
}
|
|
|
|
void SpreaderOrderMan::on(event::CancelSpreaderOrder const&cancel)
|
|
{
|
|
LOG(OrderMan,Diag, "CancelSpreaderOrder {}",
|
|
cancel.order_key.value(),
|
|
utils::pb::to_string(cancel.cancel));
|
|
|
|
auto it = me->spreader_orders.find(cancel.order_key);
|
|
if (it != me->spreader_orders.end()) {
|
|
auto &order = *it->second.get();
|
|
order.on_cancel(cancel.cancel);
|
|
}
|
|
else
|
|
LOG(OrderMan,Error, "Ignoring attempt to cancel unknown spreader order id {}",
|
|
cancel.order_key.value());
|
|
}
|
|
|
|
void SpreaderOrderMan::on(event::BookUpdate const&book_update)
|
|
{
|
|
for (auto const &kvp : me->spreader_orders)
|
|
kvp.second->on_book(book_update.book);
|
|
}
|
|
|
|
void SpreaderOrderMan::on(event::GatewayStatusChange const&c)
|
|
{
|
|
if (c.is_connected)
|
|
for (auto const &kvp : me->spreader_orders)
|
|
kvp.second->on_connect();
|
|
else
|
|
for (auto const &kvp : me->spreader_orders)
|
|
kvp.second->on_disconnect();
|
|
}
|
|
|
|
void SpreaderOrderMan::on(event::TimeChange const&t)
|
|
{
|
|
for (auto const &kvp : me->spreader_orders)
|
|
kvp.second->on_time(t.ts);
|
|
}
|
|
|
|
void SpreaderOrderMan::on(event::NativeOrderStateChange const&ch)
|
|
{
|
|
auto ok = ch.header->parent_order_key;
|
|
if (ok != null_order_key()) {
|
|
auto it = me->spreader_orders.find(ok);
|
|
if (it != me->spreader_orders.end()) {
|
|
auto &order = *it->second.get();
|
|
auto const &state = ch.current_state;
|
|
order.on_child_update(ok,
|
|
state.order_status,
|
|
state.filled_quantity,
|
|
state.avg_price,
|
|
state.reject_msg);
|
|
}
|
|
else {
|
|
auto msg = fmt::format("Unknown parent order {} for child order {}. ",
|
|
ok.value(), ch.header->order_key.value());
|
|
LOG(OrderMan,Error,"{}",msg);
|
|
for (auto const &kvp : me->spreader_orders)
|
|
kvp.second->on_external_error(msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}}
|