def run(self):
logon = fix44.Logon()
#Keep sending a sample set of messages to server, where the second message
while (1):
message = fix.Message()
header = message.getHeader()
header.setField(fix.BeginString("FIX.4.4"))
header.setField(fix.SenderCompID("COEPUSER"))
header.setField(fix.TargetCompID("COEPEXCH"))
header.setField(fix.MsgType("D"))
message.setField(fix.ClOrdID("3"))
message.setField(fix.Symbol("amzn"))
message.setField(fix.Side(Side_BUY))
message.setField(58, "Buy shares")
message.setField(fix.Price(87))
message.setField(fix.OrderQty(2))
transact_time = datetime.utcnow()
message.setField(60, transact_time.strftime("%Y%m%d-22:29:00.000"))
message.setField(fix.Account("EXECLINKS"))
message.setField(40, "2")
status = fix.Session.sendToTarget(message, self.sessionID)
print("Status: ", status)
print(message)
time.sleep(5)
message = fix.Message()
header = message.getHeader()
header.setField(fix.BeginString("FIX.4.4"))
header.setField(fix.SenderCompID("COEPUSER"))
header.setField(fix.TargetCompID("COEPEXCH"))
header.setField(fix.MsgType("D"))
message.setField(fix.ClOrdID("3"))
message.setField(fix.Symbol("amzn"))
message.setField(fix.Side(Side_SELL))
message.setField(58, "Sell shares")
message.setField(fix.Price(87))
message.setField(fix.OrderQty(2))
transact_time = datetime.utcnow()
message.setField(60, transact_time.strftime("%Y%m%d-22:29:00.000"))
message.setField(fix.Account("EXECLINKS"))
message.setField(40, "2")
status = fix.Session.sendToTarget(message, self.sessionID)
print("Status: ", status)
print(message)
time.sleep(100)
def securityDefinitionRequest(self):
msg = fix50.SecurityDefinitionRequest()
header = msg.getHeader()
header.setField(fix.BeginString(fix.BeginString_FIXT11))
# header.setField(fix.MsgType(msgType))
header.setField(fix.SenderCompID("pjseoane232"))
header.setField(fix.TargetCompID("ROFX"))
def market_data_request(self, sender_comp_id, target_comp_id, symbols):
md_types = [
fix.MDEntryType_BID, fix.MDEntryType_OFFER, fix.MDEntryType_TRADE
]
message = fix42.MarketDataRequest()
header = message.getHeader()
header.setField(fix.SenderCompID(sender_comp_id))
header.setField(fix.TargetCompID(target_comp_id))
message.setField(fix.MDReqID(self._generate_id()))
message.setField(
fix.SubscriptionRequestType(
fix.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES))
message.setField(fix.MarketDepth(10))
group = fix42.MarketDataRequest().NoMDEntryTypes()
for md_type in md_types:
group.setField(fix.MDEntryType(md_type))
message.addGroup(group)
group = fix42.MarketDataRequest().NoRelatedSym()
for symbol in symbols:
group.setField(fix.Symbol(symbol))
message.addGroup(group)
try:
fix.Session.sendToTarget(message)
except fix.SessionNotFound:
raise Exception(f"No session found {message}, exiting...")
def new_order(sender_comp_id, target_comp_id, symbol, quantity, price, side,
order_type):
if side.lower() == "buy":
side = fix.Side_BUY
else:
side = fix.Side_SELL
message = Message()
header = message.getHeader()
header.setField(fix.BeginString("FIX.4.2"))
header.setField(fix.SenderCompID(sender_comp_id))
header.setField(fix.TargetCompID(target_comp_id))
header.setField(fix.MsgType("D"))
ord_id = get_order_id(sender_comp_id, symbol)
message.setField(fix.ClOrdID(ord_id))
message.setField(fix.Symbol(symbol))
message.setField(fix.Side(side))
message.setField(fix.Price(float(price)))
if order_type.lower() == "market":
message.setField(fix.OrdType(fix.OrdType_MARKET))
else:
message.setField(fix.OrdType(fix.OrdType_LIMIT))
message.setField(fix.HandlInst(fix.HandlInst_MANUAL_ORDER_BEST_EXECUTION))
message.setField(fix.TransactTime())
message.setField(fix.OrderQty(float(quantity)))
message.setField(fix.Text(f"{side} {symbol} {quantity}@{price}"))
return message
def scrip_msg(scrip_element: Scrip):
scrip_subscription = fix.Message()
# 8, BeginString
scrip_subscription.getHeader().setField(fix.BeginString(fix.BeginString_FIXT11))
# 35, Message Type
scrip_subscription.getHeader().setField(fix.MsgType(fix.MsgType_MarketDataRequest))
# 49, SenderCompId
scrip_subscription.getHeader().setField(fix.SenderCompID(sender_id))
# 56, TargetCompId
scrip_subscription.getHeader().setField(fix.TargetCompID(target_id))
# 34, Message SeqNumber
scrip_subscription.setField(fix.MsgSeqNum(1))
# 50, SenderSubID
scrip_subscription.setField(fix.SenderSubID(scrip_element.exchange))
# 924, UserRequestType
scrip_subscription.setField(fix.UserRequestType(1))
# 115 ,doubtful, but may be gateway id according to examples
# NSECM = 2, NSEFO = 1
scrip_subscription.setField(115, "%s" % scrip_element.gatewayID)
# 55, Symbol
scrip_subscription.setField(fix.Symbol(scrip_element.symbol))
# 1775, price divisor
scrip_subscription.setField(1775, "0")
# 167, Instrument
scrip_subscription.setField(167, scrip_element.instrument)
# 48, Token No.
scrip_subscription.setField(48, "%s" % scrip_element.token_no)
# 263, Broadcast type
scrip_subscription.setField(263, "0")
scrip_subscription = bytes(scrip_subscription.toString(), encoding="UTF-8")
return scrip_subscription
def suscribeMD(self):
print(
"SUSCRIBE MD***************************************************************************"
)
if len(self.tickers) == 0 or len(self.entries) == 0:
return
allowed_entries = ['0', '1', '2', '4', '5', '6', '7', '8', 'B', 'C']
if not all(elem in allowed_entries for elem in self.entries):
return
msg = fix50.MarketDataRequest()
header = msg.getHeader()
header.setField(fix.SenderCompID(self.usrID))
header.setField(fix.TargetCompID(self.targetCompID))
# ---------------------
msg.setField(fix.MDReqID("ListaMktData"))
msg.setField(fix.SubscriptionRequestType('1'))
msg.setField(fix.MarketDepth(1))
msg.setField(fix.MDUpdateType(0))
msg.setField(fix.AggregatedBook(True))
# BlockMDReqGrp
group = fix50.MarketDataRequest().NoMDEntryTypes()
for field in self.entries:
group.setField(fix.MDEntryType(str(field)))
msg.addGroup(group)
# Symbols
norelatedsym = fix50.MarketDataRequest().NoRelatedSym()
for ticker in self.tickers:
norelatedsym.setField(fix.Symbol(ticker))
logfix.warning("--> Suscribe Ticker >> (%s)" % ticker)
msg.addGroup(norelatedsym)
fix.Session.sendToTarget(msg)
def buildMsgHeader(self, msgType):
self.msg = msg = fix.Message()
header = msg.getHeader()
header.setField(fix.BeginString(fix.BeginString_FIXT11))
header.setField(fix.MsgType(msgType))
header.setField(fix.SenderCompID("pjseoane232"))
header.setField(fix.TargetCompID("ROFX"))
return self.msg
def test_checkHasRequired(self):
self.object.setVersion(fix.BeginString_FIX40)
self.object.addField(fix.BeginString().getTag())
self.object.addField(fix.BodyLength().getTag())
self.object.addField(fix.MsgType().getTag())
self.object.addField(fix.SenderCompID().getTag())
self.object.addField(fix.TargetCompID().getTag())
self.object.addHeaderField(fix.SenderCompID().getTag(), True)
self.object.addHeaderField(fix.TargetCompID().getTag(), False)
self.object.addField(fix.CheckSum().getTag())
self.object.addField(fix.TestReqID().getTag())
self.object.addMsgType(fix.MsgType_TestRequest)
self.object.addMsgField(fix.MsgType_TestRequest,
fix.TestReqID().getTag())
self.object.addRequiredField(fix.MsgType_TestRequest,
fix.TestReqID().getTag())
message = fix40.TestRequest()
try:
self.object.validate(message)
self.failUnless(0)
except fix.Exception as e:
self.failUnless(1)
message.getHeader().setField(fix.SenderCompID("SENDER"))
try:
self.object.validate(message)
self.failUnless(0)
except fix.Exception as e:
self.failUnless(1)
message.setField(fix.TestReqID("1"))
try:
self.object.validate(message)
self.failUnless(1)
except fix.Exception as e:
self.failUnless(0)
message.getHeader().removeField(fix.SenderCompID().getTag())
message.setField(fix.SenderCompID("SENDER"))
try:
self.object.validate(message)
self.failUnless(0)
except fix.Exception as e:
self.failUnless(1)
def getSecuritiesList(self):
msg = fix50.SecurityListRequest()
header = msg.getHeader()
header.setField(fix.SenderCompID(self.usrID))
header.setField(fix.TargetCompID(self.targetCompID))
msg.setField(fix.SecurityReqID('ListRequest1'))
msg.setField(fix.SecurityListRequestType(4))
fix.Session.sendToTarget(msg)
def market_data_request(self, sender_comp_id, target_comp_id, symbols):
md_types = [
fix.MDEntryType_BID, fix.MDEntryType_OFFER, fix.MDEntryType_TRADE
]
message = fix44.MarketDataRequest()
header = message.getHeader()
header.setField(fix.SenderCompID(sender_comp_id))
header.setField(fix.TargetCompID(target_comp_id))
message.setField(fix.MDReqID(self._generate_id()))
message.setField(
fix.SubscriptionRequestType(
fix.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES))
# message.setField(
# fix.SubscriptionRequestType(
# fix.SubscriptionRequestType_SNAPSHOT
# )
# )
"""
Valid values:
0 = Full Book
1 = Top of Book
N>1 = Report best N price tiers of data
"""
message.setField(fix.MarketDepth(0))
"""
Valid values:
0 = Full Refresh
1 = Incremental Refresh
"""
message.setField(fix.MDUpdateType(
fix.MDUpdateType_INCREMENTAL_REFRESH))
group = fix44.MarketDataRequest().NoMDEntryTypes()
for md_type in md_types:
group.setField(fix.MDEntryType(md_type))
message.addGroup(group)
group = fix44.MarketDataRequest().NoRelatedSym()
for symbol in symbols:
group.setField(fix.Symbol(symbol))
message.addGroup(group)
try:
fix.Session.sendToTarget(message)
except fix.SessionNotFound:
raise Exception(f"No session found {message}, exiting...")
def buildMsgHeader(self, msgType):
self.msg = msg = fix.Message()
header = msg.getHeader()
header.setField(fix.BeginString(fix.BeginString_FIXT11))
header.setField(fix.ApplVerID(fix.ApplVerID_FIX50SP2))
header.setField(fix.MsgType(msgType))
header.setField(fix.SenderCompID(self.usrId))
header.setField(fix.TargetCompID("ROFX"))
return self.msg
def buildMsgHeader(self, msgType):
"""
Message Header Builder
"""
self.msg = msg = fix.Message()
header = msg.getHeader()
header.setField(fix.BeginString(fix.BeginString_FIXT11))
header.setField(fix.MsgType(msgType))
header.setField(fix.SenderCompID(self.usrID))
header.setField(fix.TargetCompID(self.targetCompID))
return self.msg
def logout_msg(sender_comp_id, target_comp_id, username_client, ):
global ntwk_id
logout_req = fix.Message()
logout_req.getHeader().setField(fix.BeginString(fix.BeginString_FIXT11))
logout_req.getHeader().setField(fix.MsgType(fix.MsgType_Logout))
logout_req.setField(fix.SenderCompID(sender_comp_id))
logout_req.setField(fix.TargetCompID(target_comp_id))
logout_req.setField(fix.MsgSeqNum(5))
logout_req.setField(fix.Username(username_client))
logout_req.setField(fix.NetworkResponseID("%s" % ntwk_id))
logout_req = bytes(logout_req.toString(), encoding="UTF-8")
return logout_req
def derivativeSecurityListRequest(self):
msg = fix.Message()
header = msg.getHeader()
header.setField(fix.BeginString(fix.BeginString_FIXT11))
header.setField(fix.MsgType("z"))
header.setField(fix.SenderCompID("pjseoane232"))
header.setField(fix.TargetCompID("ROFX"))
msg.setField(fix.SecurityReqID(self.ListaContratos))
msg.setField(fix.SecurityListRequestType(4))
#msg.setField(fix.MarketID("ROFX"))
#msg.setField(fix.MarketSegmentID("DDF"))
fix.Session.sendToTarget(msg)
def test_checkHasRequired(self):
self.object.setVersion(fix.BeginString_FIX40)
self.object.addField(fix.BeginString().getField())
self.object.addField(fix.BodyLength().getField())
self.object.addField(fix.MsgType().getField())
self.object.addField(fix.SenderCompID().getField())
self.object.addField(fix.TargetCompID().getField())
self.object.addHeaderField(fix.SenderCompID().getField(), 1)
self.object.addHeaderField(fix.TargetCompID().getField(), 0)
self.object.addField(fix.CheckSum().getField())
self.object.addField(fix.TestReqID().getField())
self.object.addMsgType(fix.MsgType_TestRequest)
self.object.addMsgField(fix.MsgType_TestRequest,
fix.TestReqID().getField())
self.object.addRequiredField(fix.MsgType_TestRequest,
fix.TestReqID().getField())
message = fix40.TestRequest()
try:
self.object.validate(message)
self.failUnless(0)
except fix.Exception, e:
self.failUnless(1)
def sendOrderCancelRequest(self):
message = fix.Message()
header = message.getHeader()
header.setField(fix.BeginString("FIX.4.2"))
header.setField(fix.SenderCompID("CLIENT1"))
header.setField(fix.TargetCompID("EXECUTOR"))
header.setField(fix.MsgType("D"))
message.setField(fix.OrigClOrdID("123"))
message.setField(fix.ClOrdID("321"))
message.setField(fix.Symbol("LNUX"))
message.setField(fix.Side(fix.Side_BUY))
message.setField(fix.Text("Cancel My Order!"))
fix.Session.sendToTarget(message, self.sessionID)
def sendHelloWorldMessage(sessionID):
message = fix.Message()
header = message.getHeader()
header.setField(fix.BeginString("FIX.4.1"))
header.setField(fix.SenderCompID("HELLOWORLD_TRADER"))
header.setField(fix.TargetCompID("HELLOWORLD_EXCHANGE"))
header.setField(fix.MsgType(fix.MsgType_NewOrderSingle))
message.setField(fix.ClOrdID('1'))
message.setField(fix.HandlInst('1'))
message.setField(fix.Symbol('BMLL'))
message.setField(fix.Side(fix.Side_BUY))
message.setField(fix.OrdType(fix.OrdType_MARKET))
message.setField(fix.Text("Hello Exchange! How are you?"))
fix.Session.sendToTarget(message, sessionID)
def delete_order(sender_comp_id, target_comp_id, orig_client_order_id):
symbol = ORDERS[orig_client_order_id][0].getValue()
side = ORDERS[orig_client_order_id][3].getValue()
message = fix44.OrderCancelRequest()
header = message.getHeader()
header.setField(fix.SenderCompID(sender_comp_id))
header.setField(fix.TargetCompID(target_comp_id))
ord_id = get_order_id(sender_comp_id, symbol)
message.setField(fix.OrigClOrdID(orig_client_order_id))
message.setField(fix.ClOrdID(ord_id))
message.setField(fix.Symbol(symbol))
message.setField(fix.Side(side))
message.setField(fix.TransactTime())
message.setField(fix.Text(f"Delete {orig_client_order_id}"))
return message
def toAdmin(self, message, sessionID):
msg = message.toString().replace(__SOH__, "|")
print("to admin called:" + msg)
msgType = message.getHeader().getField(quickfix.MsgType().getField())
print("Message Type : " + str(msgType))
if msgType == quickfix.MsgType_Logon:
sender_comp_id = message.getHeader().getField(
quickfix.SenderCompID().getField())
message.setField(quickfix.Username(sender_comp_id))
message.setField(quickfix.Password("TEST"))
msg = message.toString().replace(__SOH__, "|")
print("to admin called:")
print("Thread ID: " + str(threading.get_ident()))
print("to admin called: " + sessionID.toString() + " : " + msg)
return
def security_definition_request(self, sender_comp_id, target_comp_id):
message = fix44.SecurityDefinitionRequest()
header = message.getHeader()
header.setField(fix.SenderCompID(sender_comp_id))
header.setField(fix.TargetCompID(target_comp_id))
message.setField(fix.SecurityReqID(self._generate_id()))
message.setField(
fix.SecurityRequestType(
fix.SecurityRequestType_REQUEST_LIST_SECURITIES))
# group = fix44.SecurityDefinitionRequest().Instrument()
# Instrument
# for md_type in md_types:
# group.setField(fix.MDEntryType(md_type))
# message.addGroup(group)
try:
fix.Session.sendToTarget(message)
except fix.SessionNotFound:
raise Exception(f"No session found {message}, exiting...")
def marketDataRequest(self):
# pag 63
msg = fix50.MarketDataRequest()
header = msg.getHeader()
# header.setField(fix.BeginString(fix.BeginString_FIXT11))
# header.setField(fix.MsgType(msgType))
header.setField(fix.SenderCompID("pjseoane232"))
header.setField(fix.TargetCompID("ROFX"))
# msg = self.buildMsgHeader("V")
msg.setField(fix.MDReqID("ListaMktData2"))
msg.setField(fix.SubscriptionRequestType('2'))
msg.setField(fix.MarketDepth(1))
msg.setField(fix.MDUpdateType(0))
msg.setField(fix.AggregatedBook(True))
# msg.setField(fix.NoMDEntryTypes(2))
# ---- define Group
group = fix50.MarketDataRequest().NoMDEntryTypes()
group.setField(fix.MDEntryType('0'))
msg.addGroup(group)
# group = fix50.MarketDataRequest().NoMDEntryTypes()
group.setField(fix.MDEntryType('1'))
msg.addGroup(group)
# group3 = fix50.MarketDataRequest().NoMDEntryTypes()
# group3.setField(fix.MDEntryType('2'))
# msg.addGroup(group3)
# -----------------------------------------
msg.setField(fix.NoRelatedSym(1))
group = fix50.MarketDataRequest().NoRelatedSym()
group.setField(fix.Symbol("RFX20Sep19"))
msg.addGroup(group)
fix.Session.sendToTarget(msg)
def replace_order(sender_comp_id, target_comp_id, quantity, price,
orig_client_order_id):
symbol = ORDERS[orig_client_order_id][0].getValue()
side = ORDERS[orig_client_order_id][3].getValue()
message = fix42.OrderCancelReplaceRequest()
header = message.getHeader()
header.setField(fix.SenderCompID(sender_comp_id))
header.setField(fix.TargetCompID(target_comp_id))
ord_id = get_order_id(sender_comp_id, symbol)
message.setField(fix.OrigClOrdID(orig_client_order_id))
message.setField(fix.ClOrdID(ord_id))
message.setField(fix.Symbol(symbol))
message.setField(fix.Side(side))
message.setField(fix.Price(float(price)))
message.setField(fix.OrdType(fix.OrdType_LIMIT))
message.setField(fix.HandlInst(fix.HandlInst_MANUAL_ORDER_BEST_EXECUTION))
message.setField(fix.TransactTime())
message.setField(fix.TransactTime())
message.setField(fix.OrderQty(float(quantity)))
message.setField(fix.Text(f"{side} {symbol} {quantity}@{price}"))
return message
def logon_msg(sender_comp_id, target_comp_id, username_client, response_id_network):
if response_id_network is None:
response_id_network = int((numpy.random.random()) * 100000)
global ntwk_id
ntwk_id = response_id_network
_message_logger.info("Logon with response id: %s" % response_id_network)
_message_logger.debug("Building logon message")
logon_req = fix.Message()
logon_req.getHeader().setField(fix.BeginString(fix.BeginString_FIXT11))
logon_req.getHeader().setField(fix.MsgType(fix.MsgType_Logon))
logon_req.setField(fix.SenderCompID(sender_comp_id))
logon_req.setField(fix.TargetCompID(target_comp_id))
logon_req.setField(fix.MsgSeqNum(1))
logon_req.setField(fix.UserRequestType(1))
logon_req.setField(fix.HeartBtInt(1))
logon_req.setField(fix.Username(username_client))
logon_req.setField(fix.NetworkResponseID("%s" % response_id_network))
logon_req.setField(fix.DefaultApplVerID(fix.ApplVerID_FIX50SP2))
logon_req.setField(1701, "1")
logon_req.getTrailer().setField(fix.MarketID("2"))
logon_req.setField(fix.DefaultApplVerID("FIX.5.0SP2"))
logon_req = bytes(logon_req.toString(), encoding="UTF-8")
_message_logger.debug("Logon message built")
return logon_req
def onNOS(self, message):
trade = fix.Message()
header = trade.getHeader()
header.setField(fix.BeginString("FIX.4.4"))
header.setField(fix.SenderCompID("COEPUSER"))
header.setField(fix.TargetCompID("COEPEXCH"))
header.setField(fix.MsgType("D"))
trade.setField(fix.ClOrdID(message['order_id']))
trade.setField(fix.Symbol(message['symbol']))
if message['side'] == 'sell':
trade.setField(fix.Side(Side_SELL))
trade.setField(58, "Sell shares")
else:
trade.setField(fix.Side(Side_BUY))
trade.setField(58, "Buy shares")
trade.setField(40, "2")
trade.setField(fix.Price(message['ask_price']))
trade.setField(fix.OrderQty(message['total_qty']))
transact_time = datetime.utcnow()
trade.setField(60, transact_time.strftime("%Y%m%d-22:29:00.000"))
trade.setField(fix.Account("EXECLINKS"))
fix.Session_sendToTarget(trade, self.sessionID)
return
def test_reverseRoute(self):
header = fix.Header()
beginString = fix.BeginString( "FIX.4.2" )
senderCompID = fix.SenderCompID( "SenderCompID" )
targetCompID = fix.TargetCompID( "TargetCompID" )
onBehalfOfCompID = fix.OnBehalfOfCompID( "OnBehalfOfCompID" )
onBehalfOfSubID = fix.OnBehalfOfSubID( "OnBehalfOfSubID" )
onBehalfOfLocationID = fix.OnBehalfOfLocationID( "OnBehalfOfLocationID" )
deliverToCompID = fix.DeliverToCompID( "DeliverToCompID" )
deliverToSubID = fix.DeliverToSubID( "DeliverToSubID" )
deliverToLocationID = fix.DeliverToLocationID( "DeliverToLocationID" )
reversedMessage = fix.Message()
reversedHeader = reversedMessage.getHeader()
header.setField( beginString )
header.setField( senderCompID )
header.setField( targetCompID )
header.setField( onBehalfOfCompID )
header.setField( onBehalfOfSubID )
header.setField( onBehalfOfLocationID )
header.setField( deliverToCompID )
header.setField( deliverToSubID )
header.setField( deliverToLocationID )
reversedMessage.reverseRoute( header );
self.assertTrue( reversedHeader.getField( beginString ).getString() == "FIX.4.2" )
self.assertTrue( reversedHeader.getField( senderCompID ).getString() == "TargetCompID" )
self.assertTrue( reversedHeader.getField( targetCompID ).getString() == "SenderCompID" )
self.assertTrue( reversedHeader.getField( onBehalfOfCompID ).getString() == "DeliverToCompID" )
self.assertTrue( reversedHeader.getField( onBehalfOfSubID ).getString() == "DeliverToSubID" )
self.assertTrue( reversedHeader.getField( onBehalfOfLocationID ).getString() == "DeliverToLocationID" )
self.assertTrue( reversedHeader.getField( deliverToCompID ).getString() == "OnBehalfOfCompID" )
self.assertTrue( reversedHeader.getField( deliverToSubID ).getString() == "OnBehalfOfSubID" )
self.assertTrue( reversedHeader.getField( deliverToLocationID ).getString() == "OnBehalfOfLocationID" )
header.setField( fix.BeginString("FIX.4.0" ) )
reversedMessage.reverseRoute( header )
self.assertTrue( reversedHeader.isSetField( onBehalfOfLocationID ) == 0 )
self.assertTrue( reversedHeader.isSetField( deliverToLocationID ) == 0 )
header.setField( beginString )
reversedMessage.reverseRoute( header )
header.removeField( fix.OnBehalfOfCompID().getTag() )
reversedMessage.reverseRoute( header )
self.assertTrue( reversedHeader.isSetField(deliverToCompID) == 0 )
header.removeField( fix.DeliverToCompID().getTag() )
reversedMessage.reverseRoute( header )
self.assertTrue( reversedHeader.isSetField(onBehalfOfCompID) == 0 )
header.removeField( fix.OnBehalfOfSubID().getTag() )
reversedMessage.reverseRoute( header )
self.assertTrue( reversedHeader.isSetField(deliverToSubID) == 0 )
header.removeField( fix.DeliverToSubID().getTag() )
reversedMessage.reverseRoute( header )
self.assertTrue( reversedHeader.isSetField(onBehalfOfSubID) == 0 )
header.removeField( fix.OnBehalfOfLocationID().getTag() )
reversedMessage.reverseRoute( header )
self.assertTrue( reversedHeader.isSetField(deliverToLocationID) == 0 )
header.removeField( fix.DeliverToLocationID().getTag() )
reversedMessage.reverseRoute( header )
self.assertTrue( reversedHeader.isSetField(onBehalfOfLocationID) == 0 )
mode="a",
maxBytes=5 * 1024 * 1024,
backupCount=50)
fmt = logging.Formatter("%(asctime)s.%(msecs)03d %(message)s")
parser_handler.setFormatter(fmt)
parser_handler.setLevel(logging.DEBUG)
_parser_logger = logging.getLogger("mega_trader.mt_data_parser")
_parser_logger.propagate = False
_parser_logger.addHandler(parser_handler)
dd = fix.DataDictionary(definitions.FIX50SP02)
begin_string = fix.BeginString()
body_length = fix.BodyLength()
message_type = fix.MsgType()
sender_id = fix.SenderCompID()
target_id = fix.TargetCompID()
msg_seq = fix.MsgSeqNum()
sender_sub_id = fix.SenderSubID()
target_sub_id = fix.TargetSubID()
duplicate_flag = fix.PossDupFlag()
user_req_type = fix.UserRequestType()
gateway_id = fix.MarketID()
orig_sending_time = fix.OrigSendingTime()
sending_time = fix.SendingTime()
on_behalf_id = fix.OnBehalfOfCompID()
check_sum = fix.CheckSum()
TOKEN_NO = 48
LTP = 1835
LTQ = 1843
def match_and_return(message):
Dict = {}
msg_type = getValue(message, 35)
#New Order Single
if (msg_type == "D"):
Dict["Order ID"] = getValue(message, 11)
Dict["Order type"] = int(getValue(message, 54)) - 1
Dict["Security ID"] = getValue(message, 55)
Dict["Order Qty"] = int(getValue(message, 38))
Dict["Price"] = float(getValue(message, 44))
Dict["Time stamp"] = getValue(message, 60)
Dict["User ID"] = "COEPUSER"
Dict["Return Order ID"] = Dict["Order ID"]
#Order Amend request
elif (msg_type == "G"):
Dict["Order ID"] = getValue(message, 41)
Dict["Order type"] = 2
Dict["Order Qty"] = int(getValue(message, 38))
Dict["Price"] = float(getValue(message, 44))
Dict["Security ID"] = getValue(message, 55)
Dict["Time stamp"] = getValue(message, 60)
Dict["User ID"] = "COEPUSER"
Dict["Return Order ID"] = getValue(message, 11)
#Order Cancel Request
elif (msg_type == "F"):
Dict["Order ID"] = getValue(message, 41)
Dict["Order type"] = 3
Dict["Return Order ID"] = getValue(message, 11)
print(Dict)
ret_list = match(Dict)
print("ret_list:", ret_list)
ret_message_list = list()
for ret_message in ret_list:
message = fix.Message()
header = message.getHeader()
header.setField(fix.BeginString("FIX.4.4"))
header.setField(fix.SenderCompID("COEPEXCH"))
header.setField(fix.TargetCompID("EXECLINKS"))
header.setField(fix.MsgType("8")) #Tag 8 for Execution report
message.setField(37, ret_message["Order ID"])
response = ret_message["Response"]
#New order accepted
if (response == 0):
message.setField(39, "0")
message.setField(150, "0")
#Amend order accepted
elif (response == 1):
message.setField(150, "5")
#Cancel order accepted
elif (response == 2):
message.setField(39, "4")
message.setField(150, "4")
#New order, amend order or cancel order rejected
elif (response == 3 or response == 4 or response == 5):
message.setField(39, "8")
message.setField(150, "8")
#Full execution of order
elif (response == 6):
message.setField(39, "2")
message.setField(150, "F")
message.setField(55, ret_message["Security ID"])
message.setField(38, str(ret_message["Order Qty"]))
message.setField(44, str(ret_message["Price"]))
#Partial execution of order
elif (response == 7):
message.setField(39, "1")
message.setField(150, "F")
message.setField(55, ret_message["Security ID"])
message.setField(38, str(ret_message["Order Qty"]))
message.setField(44, str(ret_message["Price"]))
ret_message_list.append(message)
return ret_message_list
self.object.addField(fix.CheckSum().getTag())
self.object.addField(fix.TestReqID().getTag())
self.object.addMsgType(fix.MsgType_TestRequest)
self.object.addMsgField(fix.MsgType_TestRequest,
fix.TestReqID().getTag())
self.object.addRequiredField(fix.MsgType_TestRequest,
fix.TestReqID().getTag())
message = fix40.TestRequest()
try:
self.object.validate(message)
self.failUnless(0)
except fix.Exception, e:
self.failUnless(1)
message.getHeader().setField(fix.SenderCompID("SENDER"))
try:
self.object.validate(message)
self.failUnless(0)
except fix.Exception, e:
self.failUnless(1)
message.setField(fix.TestReqID("1"))
try:
self.object.validate(message)
self.failUnless(1)
except fix.Exception, e:
self.failUnless(0)
message.getHeader().removeField(fix.SenderCompID().getTag())
message.setField(fix.SenderCompID("SENDER"))
