diff --git a/src/server/sparkd/fix/AdminModelWrapper.cpp b/src/server/sparkd/fix/AdminModelWrapper.cpp new file mode 100644 index 000000000..c187a9860 --- /dev/null +++ b/src/server/sparkd/fix/AdminModelWrapper.cpp @@ -0,0 +1,38 @@ +#include "AdminModelWrapper.h" + +#include "lib/api/service_helpers/AdminServiceUtils.h" + +#include + +namespace bts +{ + +AdminModelWrapper::AdminModelWrapper(const bts::api::admin::AdminData& data, const std::string& user_name) : + data(data), + _user_name(user_name), + _allowed_accounts() +{ + auto user = bts::admin::AdminServiceUtils::find_user(data, _user_name); + if(user && user->has_user_data() && user->user_data().has_account_permissions()) + { + for(const auto& a : user->user_data().account_permissions().account_permissions()) + { + auto account = bts::admin::AdminServiceUtils::find_account(data, a.first); + if(account) + { + if(a.second.has_trading_permission() && a.second.trading_permission().has_permissions()) + _allowed_accounts[account->name()] = 0; + if(a.second.has_admin_permission() && a.second.admin_permission().has_permissions()) + _allowed_accounts[account->name()] = 0; + } + } + } +} + +bool AdminModelWrapper::can_view_account(const std::string& account) +{ + auto it = _allowed_accounts.find(account); + return it != _allowed_accounts.end() || _user_name == "bts"; +} + +} \ No newline at end of file diff --git a/src/server/sparkd/fix/AdminModelWrapper.h b/src/server/sparkd/fix/AdminModelWrapper.h new file mode 100644 index 000000000..74e0087f8 --- /dev/null +++ b/src/server/sparkd/fix/AdminModelWrapper.h @@ -0,0 +1,28 @@ +#pragma once + +#include "lib/api/services/AdminService.pb.h" +#include "lib/api/services/AdminService.client.pb.h" + +#include +#include + +namespace bts +{ + +//see AdminModelWrapper.cs + +namespace api { namespace admin { class AdminData; } } +class AdminModelWrapper +{ +public: + AdminModelWrapper(const bts::api::admin::AdminData& data, const std::string& user_name); + + bool can_view_account(const std::string& account); + const bts::api::admin::AdminData data; + +private: + std::string _user_name; + std::unordered_map _allowed_accounts; +}; + +} \ No newline at end of file diff --git a/src/server/sparkd/fix/DropCopySession.cpp b/src/server/sparkd/fix/DropCopySession.cpp index e69de29bb..4a8147fa7 100644 --- a/src/server/sparkd/fix/DropCopySession.cpp +++ b/src/server/sparkd/fix/DropCopySession.cpp @@ -0,0 +1,156 @@ +#include "DropCopySession.h" +#include "FixRouter.h" + +#include "lib/logging/logging.h" +#include "lib/utils/bts_assert.h" +#include "lib/utils/helper_macros.h" + +#include +#include +#include +#include + +namespace bts { +namespace fix { + +DropCopySession::DropCopySession(bts::api::ServiceContext& sc, IFixRouter& rt, const FIX::SessionID& id) : + SessionBase(sc, rt, id), + _orderservice( sc.locate() ), + _order_cache() +{ +} + +DropCopySession::~DropCopySession() +{ +} + +void DropCopySession::onLogon(const FIX::SessionID& sessionID) +{ + bts_assert(sessionID == _sess); + LOG(Fix, Info, "Logged on {}", sessionID.toString()); + subscribe_fills_and_orders(sessionID); +} + +void DropCopySession::onLogout(const FIX::SessionID& sessionID) +{ + bts_assert(sessionID == _sess); + LOG(Fix, Info, "Logged out {}", sessionID.toString()); + +} + +void DropCopySession::fromApp(const FIX::Message &message,const FIX::SessionID &sessionID) + throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::UnsupportedMessageType) +{ + bts_assert(sessionID == _sess); + auto mt = message.getHeader().getField(FIX::FIELD::MsgType); + if(mt == FIX44::OrderStatusRequest::MsgType() || + mt == FIX44::SecurityDefinitionRequest::MsgType() + ) + { + LOG(Fix, Info, "DC IN: {}", message.toString() ); + crack(message, sessionID); + } + else + { + LOG(Fix, Info, "DC IN: Unsupported message in {}", mt ); + throw FIX::UnsupportedMessageType(mt); + } +} + +void DropCopySession::onMessage(const FIX44::OrderStatusRequest& req, const FIX::SessionID& s) +{ + uint oid = atoi(req.getField(FIX::FIELD::OrderID).c_str()); + auto it = _order_cache.find(oid); + if(it != _order_cache.end()) + { + auto&& ostat = build_order_status(s, *it->second); + ostat.setField(FIX::FIELD::OrdStatusReqID, req.getField(FIX::FIELD::OrdStatusReqID)); + _router.send(ostat, s); + } +} + +void DropCopySession::onMessage(const FIX44::SecurityDefinitionRequest& req, const FIX::SessionID& s) +{ + if (req.getField(FIX::FIELD::SecurityRequestType) == std::to_string(FIX::SecurityRequestType_ALL_SECURITIES)) + { + auto&& secs = _router.get_securities(); + // if (req.isSetField(FIX::FIELD::Symbol)) + // secs = secs.Where(x => x.Symbol.ToLower() == req.Symbol.getValue().ToLower()); + // if (req.IsSetSecurityType()) + // secs = secs.Where(x => security_types_equal(x.security_type(), req.SecurityType)); + // if (req.IsSetSecurityExchange()) + // secs = secs.Where(x => exchanges_equal(x.Exchange, req.SecurityExchange)); + + auto def = FIX44::SecurityDefinition(FIX::SecurityReqID(req.getField(FIX::FIELD::SecurityReqID)), + FIX::SecurityResponseID(""), + FIX::SecurityResponseType(FIX::SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST)); + _router.send(def, s); + } + else + throw FIX::IncorrectTagValue(FIX::FIELD::SecurityRequestType); +} + +void DropCopySession::subscribe_fills_and_orders(const FIX::SessionID sessionID) +{ + //TODO put this in our C++ pipe and smoke it + //var on_orders = _orderservice.Value.subscribei_orders().Naggle(interval, scheduler).PermissionFilter(_adminobservable).Table().Cache(); + //var on_fills = _orderservice.Value.subscribei_fills().Naggle(interval, scheduler).PermissionFilter(_adminobservable).Table().Cache(); + + // auto filter = rxcpp::observable<>::create([] (auto& observer) + // { + // return _adminobservable.subscribe([] (auto& x) + // { + // auto filter = [&x] (auto& z) + // { + // return x.can_view_account(z.def().account()); + // }; + // observer.on_next(filter); + // }); + // }); + + auto orders = _orderservice.subscribe_orders() | + rxcpp::operators::buffer_with_time( std::chrono::milliseconds(500) ); + + // auto admin = _adminobservable | + // rxcpp::operators::combine_latest([] (auto& admin, auto& order) + // { + // return std::make_pair(admin, order); + // }, orders) | + // rxcpp::operators::filter([] (const auto& pair) + // { + // //return pair.first.can_view_account(pair.second.def().account()); + // return true; + // }); + + orders.subscribe([this](const auto& update) + { + std::lock_guard l(_lock); + + }); +} + +void DropCopySession::process_order_state(const bts::api::orderman::OrderState& state, uint& filled, uint leaves, double& avgprx, + FIX::OrdStatus& fstatus, bts::api::orderman::NativeOrderState& native, const bts::api::orderman::Fill* fill) +{ +} + +const bts::api::Security* DropCopySession::resolve_execution_report_security(const bts::api::Security* sec, FIX44::ExecutionReport& report) +{ + return nullptr; +} + +FIX44::ExecutionReport DropCopySession::build_fill(const FIX::SessionID& sess, + const bts::api::orderman::Fill& fill, bool change) +{ + return FIX44::ExecutionReport(); +} + +FIX44::ExecutionReport DropCopySession::build_order_status(const FIX::SessionID& sess, + const bts::api::orderman::OrderRecord& order, bool change ) +{ + return FIX44::ExecutionReport(); +} + + + +}} diff --git a/src/server/sparkd/fix/DropCopySession.h b/src/server/sparkd/fix/DropCopySession.h index e69de29bb..9cb400d76 100644 --- a/src/server/sparkd/fix/DropCopySession.h +++ b/src/server/sparkd/fix/DropCopySession.h @@ -0,0 +1,52 @@ +#pragma once + +#include "SessionBase.h" + +#include +#include + +#include +#include +#include +#include +#include + +namespace FIX44 +{ + class OrderStatusRequest; + class SecurityDefinitionRequest; +} + +namespace bts { +namespace fix { + +class DropCopySession : public SessionBase +{ +public: + DropCopySession(bts::api::ServiceContext&, IFixRouter&, const FIX::SessionID&); + virtual ~DropCopySession(); + + void onLogon(const FIX::SessionID&); + void onLogout(const FIX::SessionID&); + + void fromApp(const FIX::Message &message,const FIX::SessionID &sessionID) + throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::UnsupportedMessageType); + + void onMessage(const FIX44::OrderStatusRequest& m, const FIX::SessionID& s); + void onMessage(const FIX44::SecurityDefinitionRequest& m, const FIX::SessionID& s); + +protected: + virtual void subscribe_fills_and_orders(const FIX::SessionID sessionID); + virtual void process_order_state(const bts::api::orderman::OrderState& state, uint& filled, uint leaves, double& avgprx, + FIX::OrdStatus& fstatus, bts::api::orderman::NativeOrderState& native, const bts::api::orderman::Fill* fill = nullptr); + + const bts::api::Security* resolve_execution_report_security(const bts::api::Security* sec, FIX44::ExecutionReport& report); + virtual FIX44::ExecutionReport build_fill(const FIX::SessionID& sess, const bts::api::orderman::Fill& fill, bool change = false); + virtual FIX44::ExecutionReport build_order_status(const FIX::SessionID& sess, const bts::api::orderman::OrderRecord& order, bool change = false); + +protected: + bts::api::orderman::OrderService _orderservice; + std::unordered_map _order_cache; +}; + +}} diff --git a/src/server/sparkd/fix/FixInit.cpp b/src/server/sparkd/fix/FixInit.cpp index a42919c7d..27779b736 100644 --- a/src/server/sparkd/fix/FixInit.cpp +++ b/src/server/sparkd/fix/FixInit.cpp @@ -23,18 +23,15 @@ namespace bts { namespace fix { - -GCC_DIAG_OFF("-Wdeprecated") -GCC_DIAG_OFF("-Wignored-qualifiers") - -int FixInit::start_acceptor(bts::api::ServiceContext&, md::MDClient& md, const std::string& settings_file, bool orders_allowed) + +int FixInit::start_acceptor(bts::api::ServiceContext& sc, md::MDClient& md, const std::string& settings_file, bool orders_allowed) { std::ifstream str{settings_file}; FIX::SessionSettings settings( str ); - FixRouter application(md, [=](IFixRouter& router, const auto& id) + FixRouter application(md, [&](IFixRouter& router, const auto& id) { - return std::shared_ptr(); + return std::shared_ptr(new DropCopySession(sc, router, id)); // if(orders_allowed) // return std::shared_ptr(new OrderSession(sc, router, id)); // else diff --git a/src/server/sparkd/fix/FixRouter.cpp b/src/server/sparkd/fix/FixRouter.cpp index c56e9f7ac..d7a366b06 100644 --- a/src/server/sparkd/fix/FixRouter.cpp +++ b/src/server/sparkd/fix/FixRouter.cpp @@ -10,6 +10,8 @@ #include #include #include +#include +#include #include @@ -47,51 +49,131 @@ FixRouter::~FixRouter() { } -void FixRouter::send(const FIX::Message&, const FIX::SessionID&) +void FixRouter::send(FIX::Message& mess, const FIX::SessionID& sess) { +std::lock_guard guard(me->lock); + try + { + FIX::Session::sendToTarget(mess, sess); + } + catch(FIX::SessionNotFound) + { + bts_assert_msg(false, "session not found " + sess.toString()); + } + catch(std::exception ex) + { + LOG(Fix, Error, "session error {} {}", sess.toString(), std::string(ex.what())); + } } void FixRouter::send_session_reject(const FIX::SessionID& sess, const std::string& text, const FIX::Message* refmessage) { + FIX44::Reject rej; + if(refmessage && refmessage->getHeader().isSetField(FIX::FIELD::MsgSeqNum)) + rej.setField(FIX::FIELD::RefSeqNum, refmessage->getHeader().getField(FIX::FIELD::MsgSeqNum)); + rej.setField(FIX::FIELD::Text, text); + send(rej, sess); } void FixRouter::send_biz_reject(const FIX::SessionID sess, const std::string& text, const FIX::Message& refmessage, int reason_code) { + FIX44::BusinessMessageReject rej; + rej.setField(FIX::FIELD::RefMsgType, refmessage.getHeader().getField(FIX::FIELD::MsgType)); + rej.setField(FIX::FIELD::RefSeqNum, refmessage.getHeader().getField(FIX::FIELD::MsgSeqNum)); + rej.setField(FIX::FIELD::BusinessRejectReason, std::to_string(reason_code)); + rej.setField(FIX::FIELD::Text, text); } void FixRouter::fromAdmin(const FIX::Message& message, const FIX::SessionID& sessionID) throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::RejectLogon) { + try + { + session(sessionID).fromAdmin(message, sessionID); + } + catch (FIX::FieldNotFound ex) { handle_field_not_found(ex, sessionID, message); } + catch (FIX::UnsupportedMessageType) { throw; } + catch (FIX::IncorrectTagValue) { throw; } + catch (std::exception ex) { handle_session_exception(ex, sessionID, &message); } } void FixRouter::fromApp(const FIX::Message &message,const FIX::SessionID &sessionID) throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::UnsupportedMessageType) { + try + { + session(sessionID).fromApp(message, sessionID); + } + catch (FIX::FieldNotFound ex) { handle_field_not_found(ex, sessionID, message); } + catch (FIX::UnsupportedMessageType) { throw; } + catch (FIX::IncorrectTagValue) { throw; } + catch (std::exception ex) { handle_session_exception(ex, sessionID, &message); } } -void FixRouter::onCreate(const FIX::SessionID&) +void FixRouter::onCreate(const FIX::SessionID& sessionID) { + try + { + session(sessionID).onCreate(sessionID); + } + catch(std::exception ex) + { + handle_session_exception(ex, sessionID); + } } -void FixRouter::onLogon(const FIX::SessionID&) +void FixRouter::onLogon(const FIX::SessionID& sessionID) { + try + { + session(sessionID).onLogon(sessionID); + } + catch (std::exception ex) + { + handle_session_exception(ex, sessionID); + } } -void FixRouter::onLogout(const FIX::SessionID&) +void FixRouter::onLogout(const FIX::SessionID& sessionID) { + try + { + //TODO stackoverflow? + session(sessionID).onLogout(sessionID); + } + catch (std::exception ex) + { + handle_session_exception(ex, sessionID); + } } -void FixRouter::toAdmin(FIX::Message&, const FIX::SessionID&) +void FixRouter::toAdmin(FIX::Message& message, const FIX::SessionID& sessionID) { + try + { + session(sessionID).toAdmin(message, sessionID); + } + catch (FIX::FieldNotFound ex) { handle_field_not_found(ex, sessionID, message); } + catch (FIX::UnsupportedMessageType) { throw; } + catch (FIX::IncorrectTagValue) { throw; } + catch (std::exception ex) { handle_session_exception(ex, sessionID, &message); } } -void FixRouter::toApp(FIX::Message&, const FIX::SessionID&) throw(FIX::DoNotSend) +void FixRouter::toApp(FIX::Message& message, const FIX::SessionID& sessionID) throw(FIX::DoNotSend) { + try + { + session(sessionID).toApp(message, sessionID); + } + catch (FIX::FieldNotFound ex) { handle_field_not_found(ex, sessionID, message); } + catch (FIX::UnsupportedMessageType) { throw FIX::DoNotSend() ; } + catch (FIX::IncorrectTagValue) { throw FIX::DoNotSend() ; } + catch (std::exception ex) { handle_session_exception(ex, sessionID, &message); } } IFixSession& FixRouter::session(const FIX::SessionID& sid) { - std::lock_guard guard(me->lock); +std::lock_guard guard(me->lock); auto it = me->sessions.find(sid); if(it == me->sessions.end()) { @@ -105,10 +187,32 @@ IFixSession& FixRouter::session(const FIX::SessionID& sid) void FixRouter::handle_session_exception(const std::exception& ex, const FIX::SessionID& sessionID, const FIX::Message* message) { + std::string msg = "==ERROR in session " + sessionID.toString() + "== "; + msg += (message ? message->getHeader().getField(FIX::FIELD::MsgType) : ""); + msg += std::string(ex.what()); + + LOG(Fix, Error, msg.c_str()); + //now shut this fucker down + try + { + auto sess = FIX::Session::lookupSession(sessionID); + if(sess != nullptr) + sess->disconnect(); + } + catch(...) { } } void FixRouter::handle_field_not_found(const FIX::FieldNotFound& ex, const FIX::SessionID& sess, const FIX::Message& message) { + if(ex.field > 0) + { + std::string text = "Field " + std::to_string(ex.field) + " was expected but not found"; + send_biz_reject(sess, text, message, 5 ); + } + //QF does not include the tag number.... + //throw new FieldNotFoundException($"Field {ex.Field} was expected but not found", ex); + else + throw ex; } std::vector FixRouter::get_securities() diff --git a/src/server/sparkd/fix/FixRouter.h b/src/server/sparkd/fix/FixRouter.h index 7b12ee954..0edc0f770 100644 --- a/src/server/sparkd/fix/FixRouter.h +++ b/src/server/sparkd/fix/FixRouter.h @@ -27,7 +27,7 @@ public: FixRouter(md::MDClient&, Factory factory); ~FixRouter(); - void send(const FIX::Message&, const FIX::SessionID&) override; + void send(FIX::Message&, const FIX::SessionID&) override; void send_session_reject(const FIX::SessionID& sess, const std::string& text, const FIX::Message* refmessage = nullptr) override; void send_biz_reject(const FIX::SessionID sess, const std::string& text, const FIX::Message& refmessage, int reason_code = 0) override; diff --git a/src/server/sparkd/fix/IFixRouter.h b/src/server/sparkd/fix/IFixRouter.h index 191809b4e..925338c69 100644 --- a/src/server/sparkd/fix/IFixRouter.h +++ b/src/server/sparkd/fix/IFixRouter.h @@ -29,7 +29,7 @@ namespace fix virtual const md::SecurityPtr lookup(md::security_key key) = 0; virtual const md::SecurityPtr lookup(const std::string& desc) = 0; - virtual void send(const FIX::Message& mess, const FIX::SessionID& sess) = 0; + virtual void send(FIX::Message& mess, const FIX::SessionID& sess) = 0; virtual void send_session_reject(const FIX::SessionID& sess, const std::string& text, const FIX::Message* refmessage = nullptr) = 0; virtual void send_biz_reject(const FIX::SessionID sess, const std::string& text, const FIX::Message& refmessage, int reason_code = 0) = 0; }; diff --git a/src/server/sparkd/fix/SessionBase.cpp b/src/server/sparkd/fix/SessionBase.cpp index bd22249a6..0f9f63523 100644 --- a/src/server/sparkd/fix/SessionBase.cpp +++ b/src/server/sparkd/fix/SessionBase.cpp @@ -3,14 +3,17 @@ #include "IFixRouter.h" #include "lib/api/public/ServiceContext.h" +#include "lib/api/service_helpers/AdminServiceUtils.h" #include "lib/utils/AuthToken.h" #include "lib/logging/logging.h" #include "lib/utils/bts_assert.h" -#include "lib/api/service_helpers/AdminServiceUtils.h" - +#include "lib/utils/helper_macros.h" #include +#include #include +#include +#include #include #include #include @@ -22,40 +25,92 @@ namespace bts { namespace fix { SessionBase::SessionBase(bts::api::ServiceContext& sc, IFixRouter& router, const FIX::SessionID& sess) : - _auth_service( sc.locate() ), - _admin_service( sc.locate() ), + _authservice( sc.locate() ), + _adminservice( sc.locate() ), + _admin_data(), + _user_name(), _token(), _router(router), - _sess(sess), - _admin_data(), + _sess(sess), _lock() { - _admin_service.get_admin_data(api::VoidMessage(), [this] (auto result) - { - std::lock_guard guard(_lock); - if(result.success()) - _admin_data = *result.value(); - }); + _adminobservable = _adminservice.subscribe_admin_data() | + rxcpp::operators::map( + [this](const auto& update) + { + std::lock_guard l(_lock); + bts_assert(update.all().size() == 1); + _admin_data = *update.all()[0]; + return std::shared_ptr(new AdminModelWrapper(_admin_data, _user_name) ); + }); + } SessionBase::~SessionBase() { } + void SessionBase::fromAdmin(const FIX::Message& message, const FIX::SessionID& sessionID) throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::RejectLogon) { bts_assert_msg(sessionID == _sess, "invalid session"); -} -void SessionBase::fromApp(const FIX::Message&,const FIX::SessionID&) - throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::UnsupportedMessageType) -{ + FIX::MsgType type; + message.getHeader().getField(type); + if(type.getString() == FIX44::Logon::MsgType()) + { + try + { + FIX44::Logon msg = (FIX44::Logon)message; + _user_name = msg.getField(FIX::FIELD::Username); + std::string pass; + if(msg.isSetField(FIX::FIELD::Password)) + pass = msg.getField(FIX::FIELD::Password); + + bts::api::user::AuthenticateLoginRequest auth; + auth.set_login(_user_name); + auth.set_password(pass); + _authservice.authenticate_login(auth, [this] (auto resp) + { + if (resp.success() && resp.value()->is_valid()) + _token = resp.value()->token(); + else + throw FIX::RejectLogon("Logon rejected " + resp.value()->reason()); + }); + } + catch (FIX::RejectLogon) + { + throw; + } + catch (std::exception ex) + { + throw FIX::RejectLogon("Logon rejected " + std::string(ex.what())); + } + } + else if(type.getString() == FIX44::Heartbeat::MsgType()) + { + FIX44::Heartbeat hb = (FIX44::Heartbeat)message; + handle_heartbeat(hb, sessionID); + } + else + { + LOG(Fix, Info, "ADMININ: {}", message.toString() ); + } } -void SessionBase::toAdmin(FIX::Message&, const FIX::SessionID&) +void SessionBase::handle_heartbeat(const FIX44::Heartbeat& hb, const FIX::SessionID& sessionID) { + //TODO I'd previously sent this to the latency service when it was out of process, not sure what to do now + UNUSED(hb); + UNUSED(sessionID); +} + +void SessionBase::toAdmin(FIX::Message& m, const FIX::SessionID& sessionID) +{ + bts_assert_msg(sessionID == _sess, "invalid session"); + LOG(Fix, Info, "ADMINOUT: {}", m.toString()); } void SessionBase::toApp(FIX::Message& m, const FIX::SessionID&) throw(FIX::DoNotSend) @@ -63,6 +118,11 @@ void SessionBase::toApp(FIX::Message& m, const FIX::SessionID&) throw(FIX::DoNot LOG(Fix, Info, "OUT: {}", m.toString()); } +void SessionBase::onCreate(const FIX::SessionID& s) +{ + LOG(Fix, Info, "CREATE: {}", s.toString()); +} + void SessionBase::onMessage(const FIX44::BusinessMessageReject& n, const FIX::SessionID& s) { LOG(Fix, Warn, "{} Business Reject: {} {}", s.toString(), n.getField(FIX::FIELD::BusinessRejectReason), n.getField(FIX::FIELD::Text) ); @@ -176,10 +236,58 @@ bts::api::Venue SessionBase::convert_exchange(FIX::SecurityExchange fixtype) return bts::api::Venue::VENUE_UNSET; } -FIX::OrdStatus SessionBase::translate_status(const bts::api::orderman::OrderStateImmutable& state, - bts::api::orderman::NativeOrderStateImmutable* native) +FIX::OrdStatus SessionBase::translate_status(const bts::api::orderman::OrderState& state, + bts::api::orderman::NativeOrderState* native) { - return FIX::OrdStatus(); + if (state.has_market() && state.market().has_native_state() && state.market().native_state().native_status() != bts::api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_UNACKNOWLEDGED) + { + *native = state.market().native_state(); + return FIX::OrdStatus((char)native->native_status()); + } + else if (state.has_limit() && state.limit().has_native_state() && state.limit().native_state().native_status() != bts::api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_UNACKNOWLEDGED) + { + *native = state.limit().native_state(); + return FIX::OrdStatus((char)native->native_status()); + } + else if (state.has_stop() && state.stop().has_native_state() && state.stop().native_state().native_status() != bts::api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_UNACKNOWLEDGED) + { + *native = state.stop().native_state(); + return FIX::OrdStatus((char)native->native_status()); + } + else if (state.has_stop_limit() && state.stop_limit().has_native_state() && state.stop_limit().native_state().native_status() != bts::api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_UNACKNOWLEDGED) + { + *native = state.stop_limit().native_state(); + return FIX::OrdStatus((char)native->native_status()); + } + else + { + switch (state.status()) + { + case bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED: + return FIX::OrdStatus(FIX::OrdStatus_CANCELED); + case bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED: + return FIX::OrdStatus(FIX::OrdStatus_FILLED); + case bts::api::orderman::OrderStatus::ORDER_STATUS_DISCONNECTED: + return FIX::OrdStatus(FIX::OrdStatus_STOPPED); + case bts::api::orderman::OrderStatus::ORDER_STATUS_ERROR: + return FIX::OrdStatus(FIX::OrdStatus_REJECTED); + case bts::api::orderman::OrderStatus::ORDER_STATUS_INACTIVE: + return FIX::OrdStatus(FIX::OrdStatus_PENDING_NEW); + case bts::api::orderman::OrderStatus::ORDER_STATUS_PENDING_WORKING: + return FIX::OrdStatus(FIX::OrdStatus_PENDING_NEW); + case bts::api::orderman::OrderStatus::ORDER_STATUS_REJECTED_BY_SPARK: + return FIX::OrdStatus(FIX::OrdStatus_REJECTED); + case bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING: + { + if (state.filled_quantity() < state.quantity()) + return FIX::OrdStatus(FIX::OrdStatus_PARTIALLY_FILLED); + else + return FIX::OrdStatus(FIX::OrdStatus_NEW); + } + default: + return FIX::OrdStatus(); + } + } } uint SessionBase::lookup_account(const std::string& acct) diff --git a/src/server/sparkd/fix/SessionBase.h b/src/server/sparkd/fix/SessionBase.h index fce203fd4..771344929 100644 --- a/src/server/sparkd/fix/SessionBase.h +++ b/src/server/sparkd/fix/SessionBase.h @@ -1,12 +1,15 @@ #pragma once #include "IFixSession.h" +#include "AdminModelWrapper.h" #include "lib/api/public/ServiceContext.h" #include "lib/api/services/AuthService.pb.h" #include "lib/api/services/AuthService.client.pb.h" #include "lib/api/services/AdminService.pb.h" #include "lib/api/services/AdminService.client.pb.h" +#include "lib/api/services/OrderService.pb.h" +#include "lib/api/services/OrderService.client.pb.h" #include "lib/domain_model/Security.pb.h" @@ -17,23 +20,19 @@ #include #include -#include "lib/utils/warn_ctrl.h" - - namespace FIX { class Message; class SessionID; } -namespace bts { -namespace api { - namespace orderman { - class OrderStateImmutable; - class NativeOrderStateImmutable; - } +namespace FIX44 +{ + class Heartbeat; + class BusinessMessageReject; } +namespace bts { namespace fix { class IFixRouter; @@ -46,14 +45,14 @@ public: void fromAdmin(const FIX::Message& message, const FIX::SessionID& sessionID) throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::RejectLogon); - void fromApp(const FIX::Message &message,const FIX::SessionID &sessionID) - throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::UnsupportedMessageType); void toAdmin(FIX::Message&, const FIX::SessionID&); void toApp(FIX::Message&, const FIX::SessionID&) throw(FIX::DoNotSend); + void onCreate(const FIX::SessionID& s); void onMessage(const FIX44::BusinessMessageReject& n, const FIX::SessionID& s); protected: + void handle_heartbeat(const FIX44::Heartbeat& hb, const FIX::SessionID& sessionID); void send_cancel_reject(const FIX::SessionID& sess, const std::string& text, const FIX::Message& refmessage); bool security_types_equal(bts::api::SecurityType btstype, FIX::SecurityType fixtype); @@ -64,23 +63,24 @@ protected: FIX::SecurityExchange convert_exchange(bts::api::Venue btstype); bts::api::Venue convert_exchange(FIX::SecurityExchange fixtype); - FIX::OrdStatus translate_status(const bts::api::orderman::OrderStateImmutable& state, - bts::api::orderman::NativeOrderStateImmutable* native); - + FIX::OrdStatus translate_status(const bts::api::orderman::OrderState& state, + bts::api::orderman::NativeOrderState* native); uint lookup_account(const std::string& acct); uint lookup_user(const std::string& user); protected: - bts::api::user::AuthService _auth_service; - bts::api::admin::AdminService _admin_service; + bts::api::user::AuthService _authservice; + bts::api::admin::AdminService _adminservice; + + bts::api::admin::AdminData _admin_data; + rxcpp::observable> _adminobservable; std::string _user_name; bts::api::AuthToken _token; IFixRouter& _router; - const FIX::SessionID& _sess; - bts::api::admin::AdminData _admin_data; - std::mutex _lock; + const FIX::SessionID& _sess; + std::recursive_mutex _lock; }; }}