Files
spark/src/server/sparkd/fix/SessionBase.cpp
T
2019-09-26 12:33:42 -04:00

204 lines
6.8 KiB
C++

#include "SessionBase.h"
#include "IFixRouter.h"
#include "lib/api/public/ServiceContext.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 <quickfix/Message.h>
#include <quickfix/SessionID.h>
#include <quickfix/fix44/BusinessMessageReject.h>
#include <quickfix/fix44/OrderCancelReject.h>
#include <quickfix/fix44/OrderCancelRequest.h>
#include <quickfix/fix44/OrderCancelReplaceRequest.h>
#include <boost/container/flat_map.hpp>
namespace bts {
namespace fix {
SessionBase::SessionBase(bts::api::ServiceContext& sc, IFixRouter& router, const FIX::SessionID& sess) :
_auth_service( sc.locate<bts::api::user::AuthService>() ),
_admin_service( sc.locate<bts::api::admin::AdminService>() ),
_user_name(),
_token(),
_router(router),
_sess(sess),
_admin_data(),
_lock()
{
_admin_service.get_admin_data(api::VoidMessage(), [this] (auto result)
{
std::lock_guard<std::mutex> guard(_lock);
if(result.success())
_admin_data = *result.value();
});
}
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)
{
}
void SessionBase::toAdmin(FIX::Message&, const FIX::SessionID&)
{
}
void SessionBase::toApp(FIX::Message& m, const FIX::SessionID&) throw(FIX::DoNotSend)
{
LOG(Fix, Info, "OUT: {}", m.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) );
}
void SessionBase::send_cancel_reject(const FIX::SessionID& sess, const std::string& text, const FIX::Message& refmessage)
{
FIX44::OrderCancelReject rej;
if(refmessage.isSetField(FIX::FIELD::ClOrdID))
rej.setField(FIX::FIELD::ClOrdID, refmessage.getField(FIX::FIELD::ClOrdID));
if(refmessage.isSetField(FIX::FIELD::OrigClOrdID))
rej.setField(FIX::FIELD::OrigClOrdID, refmessage.getField(FIX::FIELD::OrigClOrdID));
if(refmessage.isSetField(FIX::FIELD::OrderID))
rej.setField(FIX::FIELD::OrderID, refmessage.getField(FIX::FIELD::OrderID));
rej.setField(FIX::FIELD::Text, text);
if(refmessage.getField(FIX::FIELD::MsgType) == FIX44::OrderCancelRequest::MsgType())
{
rej.setField(FIX::FIELD::CxlRejResponseTo, "1");
}
else if(refmessage.getField(FIX::FIELD::MsgType) == FIX44::OrderCancelReplaceRequest::MsgType())
{
rej.setField(FIX::FIELD::CxlRejResponseTo, "2");
}
_router.send(rej, sess);
}
bool SessionBase::security_types_equal(bts::api::SecurityType btstype, FIX::SecurityType fixtype)
{
return btstype == convert_security_type(fixtype);
}
FIX::SecurityType SessionBase::convert_security_type(bts::api::SecurityType btstype)
{
switch (btstype)
{
case bts::api::SecurityType::SECURITYTYPE_FUTURE:
return FIX::SecurityType("FUT");
case bts::api::SecurityType::SECURITYTYPE_OPTION:
return FIX::SecurityType("OPT");
case bts::api::SecurityType::SECURITYTYPE_SPREAD:
return FIX::SecurityType("MLEG");
case bts::api::SecurityType::SECURITYTYPE_STOCK:
return FIX::SecurityType("CS");
case bts::api::SecurityType::SECURITYTYPE_SYNTHETIC:
return FIX::SecurityType("SYNTH");
default:
return FIX::SecurityType();
}
}
bts::api::SecurityType SessionBase::convert_security_type(FIX::SecurityType fixtype)
{
std::string s = std::string(fixtype.getValue());
if(s == "FUT")
return bts::api::SecurityType::SECURITYTYPE_FUTURE;
else if(s == "OPT")
return bts::api::SecurityType::SECURITYTYPE_OPTION;
else if(s == "MLEG")
return bts::api::SecurityType::SECURITYTYPE_SPREAD;
else if(s == "CS")
return bts::api::SecurityType::SECURITYTYPE_STOCK;
else if("SYNTH" == s)
return bts::api::SecurityType::SECURITYTYPE_SYNTHETIC;
else
return bts::api::SecurityType::SECURITYTYPE_UNSET;
}
bool SessionBase::exchanges_equal(bts::api::Venue btstype, FIX::SecurityExchange fixtype)
{
return btstype == convert_exchange(fixtype);
}
FIX::SecurityExchange SessionBase::convert_exchange(bts::api::Venue btstype)
{
switch (btstype)
{
case bts::api::Venue::VENUE_BTS:
return FIX::SecurityExchange("BTS");
case bts::api::Venue::VENUE_CBOE:
return FIX::SecurityExchange("XCBO");
case bts::api::Venue::VENUE_CBOECFE:
return FIX::SecurityExchange("XCBF");
case bts::api::Venue::VENUE_GLBX:
return FIX::SecurityExchange("XCME");
case bts::api::Venue::VENUE_ICE:
return FIX::SecurityExchange("IFUS");
case bts::api::Venue::VENUE_SIM:
return FIX::SecurityExchange("SIM");
default:
return FIX::SecurityExchange();
}
}
bts::api::Venue SessionBase::convert_exchange(FIX::SecurityExchange fixtype)
{
std::string s = std::string(fixtype.getValue());
if("BTS" == s)
return bts::api::Venue::VENUE_BTS;
else if("XCBO" == s)
return bts::api::Venue::VENUE_CBOE;
else if("XCBF" == s)
return bts::api::Venue::VENUE_CBOECFE;
else if("GLBX" == s || "XCME" == s || "XCBT" == s || "XCEC" == s || "XNYM" == s)
return bts::api::Venue::VENUE_GLBX;
else if("IEPA" == s || "IFUS" == s || "IFEU" == s || "IFLL" == s || "IFCA" == s)
return bts::api::Venue::VENUE_ICE;
else if("SIM" == s)
return bts::api::Venue::VENUE_SIM;
else
return bts::api::Venue::VENUE_UNSET;
}
FIX::OrdStatus SessionBase::translate_status(const bts::api::orderman::OrderStateImmutable& state,
bts::api::orderman::NativeOrderStateImmutable* native)
{
return FIX::OrdStatus();
}
uint SessionBase::lookup_account(const std::string& acct)
{
auto a = admin::AdminServiceUtils::find_account(_admin_data, acct);
if(a)
return a->id();
else
throw FIX::IncorrectTagValue(FIX::FIELD::Account);
}
uint SessionBase::lookup_user(const std::string& user)
{
auto u = admin::AdminServiceUtils::find_user(_admin_data, user);
if(u)
return u->id();
else
throw FIX::IncorrectTagValue(FIX::FIELD::Username);
}
}}