150 lines
4.4 KiB
C++
150 lines
4.4 KiB
C++
#include "lib/orderman/orders/CompositeOrder.h"
|
|
#include "lib/api/services/OrderService.pb.h"
|
|
#include "lib/orderman/actors/order_manager/ChildOrder.h"
|
|
#include "lib/orderman/actors/order_manager/OrderBuilder.h"
|
|
#include "lib/orderman/orders/PreActivationOrderServices.h"
|
|
|
|
#include "lib/utils/bts_assert.h"
|
|
|
|
namespace bts {
|
|
namespace orderman {
|
|
|
|
using namespace api::orderman;
|
|
|
|
struct CompositeOrder::PImpl {
|
|
ChildOrder child_order;
|
|
OrderBuilder order_builder;
|
|
OrderServices *services;
|
|
api::orderman::OrderState state;
|
|
};
|
|
|
|
CompositeOrder::CompositeOrder() : me(new PImpl()) {}
|
|
CompositeOrder::~CompositeOrder() {}
|
|
|
|
void CompositeOrder::on_init_new(api::orderman::OrderDefinition const &def,
|
|
const PreActivationOrderServices &serv) {
|
|
bts_assert(def.custom_def().has_composite());
|
|
api::orderman::OrderDefinition child_def = def;
|
|
*child_def.mutable_custom_def() = def.custom_def();
|
|
me->order_builder = OrderBuilder{key(), child_def, serv.order_factory, 1};
|
|
me->state.set_status(ORDER_STATUS_INACTIVE);
|
|
}
|
|
|
|
void CompositeOrder::on_init_recovered(OrderRecord const &rec,
|
|
const PreActivationOrderServices &) {
|
|
|
|
me->state = rec.state();
|
|
// Infer internal status from persisted external status
|
|
switch (me->state.status()) {
|
|
|
|
case ORDER_STATUS_WORKING:
|
|
case ORDER_STATUS_PENDING_WORKING:
|
|
case ORDER_STATUS_DISCONNECTED:
|
|
me->state.set_status(ORDER_STATUS_ERROR);
|
|
me->state.set_last_msg("System restarted with active composite order");
|
|
return;
|
|
|
|
// Terminal states
|
|
case ORDER_STATUS_ERROR:
|
|
case ORDER_STATUS_REJECTED_BY_SPARK:
|
|
case ORDER_STATUS_COMPLETED:
|
|
case ORDER_STATUS_CANCELED:
|
|
break;
|
|
|
|
// It should not be possible to reach these
|
|
case ORDER_STATUS_INACTIVE:
|
|
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
|
|
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
|
|
bts_assert(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
OrderOpResult CompositeOrder::on_activate(Price p, Quantity q,
|
|
OrderServices &services) {
|
|
me->services = &services;
|
|
switch (me->state.status()) {
|
|
case ORDER_STATUS_INACTIVE:
|
|
me->order_builder.activate(services);
|
|
me->child_order = me->order_builder.build();
|
|
me->child_order.activate(p, q);
|
|
services.subscribe_to_child_updates([this](auto const &u) {
|
|
this->on_child_order_update(u.key, u.quick_rebuild_state());
|
|
});
|
|
return {};
|
|
|
|
// Terminal states
|
|
case ORDER_STATUS_ERROR:
|
|
case ORDER_STATUS_REJECTED_BY_SPARK:
|
|
case ORDER_STATUS_COMPLETED:
|
|
case ORDER_STATUS_CANCELED:
|
|
return {};
|
|
|
|
// It should not be possible to reach these
|
|
case ORDER_STATUS_DISCONNECTED:
|
|
case ORDER_STATUS_WORKING:
|
|
case ORDER_STATUS_PENDING_WORKING:
|
|
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
|
|
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
|
|
bts_assert(false);
|
|
return {};
|
|
}
|
|
|
|
bts_assert(false);
|
|
return {};
|
|
}
|
|
|
|
OrderOpResult CompositeOrder::on_update(Price p, Quantity q) {
|
|
if (is_working())
|
|
me->child_order.update(p, q);
|
|
return {};
|
|
}
|
|
|
|
OrderOpResult CompositeOrder::on_update(api::orderman::Update const &u) {
|
|
if (is_working()) {
|
|
Update child_update;
|
|
child_update.set_price(u.price());
|
|
child_update.set_quantity(u.quantity());
|
|
child_update.set_order_key(me->child_order.key().value());
|
|
|
|
if (u.has_custom()) {
|
|
bts_assert(u.custom().has_composite());
|
|
auto const &cupdate = u.custom().composite().definition();
|
|
*child_update.mutable_custom()
|
|
->mutable_composite()
|
|
->mutable_definition() = cupdate;
|
|
}
|
|
me->child_order.update(child_update);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
OrderOpResult CompositeOrder::on_detach() {
|
|
if (is_working())
|
|
me->child_order.detach();
|
|
return {};
|
|
}
|
|
|
|
OrderOpResult CompositeOrder::on_cancel() {
|
|
if (is_working())
|
|
me->child_order.cancel();
|
|
return {};
|
|
}
|
|
|
|
void CompositeOrder::on_child_order_update(
|
|
OrderKey, api::orderman::OrderState const &st) {
|
|
me->services->report_state(st);
|
|
}
|
|
|
|
bool CompositeOrder::is_working() const {
|
|
return
|
|
me->state.status() == ORDER_STATUS_WORKING ||
|
|
me->state.status() == ORDER_STATUS_PENDING_WORKING ||
|
|
me->state.status() == ORDER_STATUS_DISCONNECTED ;
|
|
}
|
|
|
|
void CompositeOrder::on_attached(api::orderman::OrderDefinition const &) {}
|
|
|
|
} // namespace orderman
|
|
} // namespace bts
|