public string BuildJSONFromString(string s, bool validateMsg = false, bool correctChks = true) { DateTime?logTimeStamp = null; int fixStart = s.IndexOf("8=FIX"); if (fixStart > 0) { string dateString = s.Substring(0, fixStart - 1); dateString = dateString.TrimEnd('\x01', ':', ' '); string format = "yyyyMMdd-HH:mm:ss.fff"; DateTime dateTime; if (DateTime.TryParseExact(dateString, format, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime)) { logTimeStamp = dateTime; } s = s.Substring(fixStart); } var msg = new QuickFix.Message(); var chksTuple = new Tuple <string, string>(string.Empty, string.Empty); string sOrigChks = null; if (correctChks) { if (!Utils.VerifyChecksum(ref s, out chksTuple, fixChecksum: true)) { sOrigChks = chksTuple.Item1; } } //--------------------------------------------------------------------------------------- msg.FromString(s, validateMsg, sessionDataDictionary, dataDictionary, messageFactory); //--------------------------------------------------------------------------------------- MsgType msgType = QuickFix.Message.IdentifyType(s); //Very inefficient. Need to rewrite to build JSON myself. XElement xElem = BuildXML(msg, msgType, logTimeStamp, sOrigChks); string jsonText = JsonConvert.SerializeXmlNode(xElem.GetXmlNode()); //================================================================= return(jsonText); //JTokenWriter writer = new JTokenWriter(); //writer.WriteStartObject(); //writer.WritePropertyName("name1"); //writer.WriteValue("value1"); //writer.WritePropertyName("name2"); //writer.WriteStartArray(); //writer.WriteValue(1); //writer.WriteValue(2); //writer.WriteEndArray(); //writer.WriteEndObject(); //JObject o = (JObject)writer.Token; //return o.ToString(); }
public new void crack(QuickFix.Message message, QuickFix.SessionID sessionID) { BeginString beginString = new BeginString(); message.getHeader().getField(beginString); String value = beginString.getValue(); if (value.Equals("FIX.4.0")) { ((QuickFix40.MessageCracker) this).crack(message, sessionID); } else if (value.Equals("FIX.4.1")) { ((QuickFix41.MessageCracker) this).crack(message, sessionID); } else if (value.Equals("FIX.4.2")) { ((QuickFix42.MessageCracker) this).crack(message, sessionID); } else if (value.Equals("FIX.4.3")) { ((QuickFix43.MessageCracker) this).crack(message, sessionID); } else if (value.Equals("FIX.4.4")) { ((QuickFix44.MessageCracker) this).crack(message, sessionID); } else { onMessage(message, sessionID); } }
// convenience constructor public Message(float step, Lifeline from, Lifeline to, String msg, float actlen, QuickFix.Message m) : this() { this.Step = step; GoText lab = this.FromLabel as GoText; if (lab != null) { lab.Text = msg; } if (from != null) { this.FromPort = from.Port; } if (to != null) { this.ToPort = to.Port; } if (actlen > 0 && to != null) { Activation act = new Activation(); act.Begin = step; act.End = step + actlen; to.Add(act); } FixMessage = m; }
//See onGatewayStatusMessage or MarketDataSnapshotFullRefresh for example of parsing a group public void parseMessage(QuickFix.Message message, QuickFix.SessionID sessionID) { try { updateDisplay(message.GetType().FullName); QuickFix.SenderSubID senderID = new SenderSubID(); QuickFix.TargetSubID targetID = new TargetSubID(); QuickFix.OnBehalfOfSubID oboID = new OnBehalfOfSubID(); if (message.getHeader().isSetField(senderID)) { updateDisplay(string.Format("SenderSubID: {0}", message.getHeader().getField(senderID))); } if (message.getHeader().isSetField(targetID)) { updateDisplay(string.Format("TargetSubID: {0}", message.getHeader().getField(targetID))); } if (message.getHeader().isSetField(oboID)) { updateDisplay(string.Format("OnBehalfOfSubID: {0}", message.getHeader().getField(oboID))); } foreach (QuickFix.Field f in message) { updateDisplay(string.Format("TAG: {0} = {1}", f.getField(), f)); } } catch (Exception ex) { updateDisplay(ex.ToString()); } }
public string BuildJSON(QuickFix.Message msg, MsgType msgType, DateTime?logTimeStamp = null, string origChkSum = null) { ////Debug.WriteLine(" ~~~> " + msg.GetType().ToString()); //SessionID sessionID = msg.GetSessionID(msg); //FIXClassInfo fixClass = null; //if (msg.GetType() == typeof(QuickFix.Message)) //{ // var classes = fixClasses[msgType.ToString(), Utils.NormalizeFIXNameSpace(sessionID.BeginString)]; // if (classes != null && classes.Count > 0) // fixClass = classes[0]; //} ////var root = new XElement(msg.GetType().ToString()); //var root = new XElement((fixClass != null) ? fixClass.type.FullName : msg.GetType().ToString()); //root.Add(new XAttribute("MessageType", msgType.ToString())); //root.Add(new XAttribute("Session", sessionID.ToString())); //if (logTimeStamp.HasValue) // root.Add(new XAttribute("LogTimeStamp", logTimeStamp.Value)); //var header = new XElement(msg.Header.GetType().ToString()); //ProcessFieldMapToXML(header, msg.Header); //root.Add(header); //var body = new XElement(msg.GetType().ToString() + ".Body"); //ProcessFieldMapToXML(body, msg); //root.Add(body); //var trailer = new XElement(msg.Trailer.GetType().ToString()); //ProcessFieldMapToXML(trailer, msg.Trailer, origChkSum); //root.Add(trailer); //return root; return(""); }
public override string ProcCancelOrder(ref bool comp, string symbol, string id, int qty) { QuickFix.Message co = (QuickFix.Message)MessageFactory.OrderCancelRequest(TradingSession()); string SecType = string.Empty, IndexSymbol = string.Empty, expiry = string.Empty, exchangeMarket = string.Empty; if (!SplitSymbol(symbol, ref SecType, ref IndexSymbol, ref expiry, ref exchangeMarket)) { return(string.Empty); } if (co == null) { return(string.Empty); } Dictionary <EFixTags, string> cancelOrderTags = new Dictionary <EFixTags, string>(); Debug.Assert(orderTypeList.ContainsKey(id), "Unable to cancel Not Exist Order Id: " + id); if (orderTypeList.ContainsKey(id)) { cancelOrderTags[EFixTags.OrigClOrderID] = id; cancelOrderTags[EFixTags.ClOrdID] = orderTypeList[id].mainOrderId + "." + (++orderTypeList[id].subOrderId); cancelOrderTags[EFixTags.Symbol] = IndexSymbol; cancelOrderTags[EFixTags.HandInst] = "2"; cancelOrderTags[EFixTags.Side] = IsBuy(qty) ? BUY : SELL; cancelOrderTags[EFixTags.OrderQty] = Math.Abs(qty).ToString(); cancelOrderTags[EFixTags.OrderType] = orderTypeList[id].IsLimit?LIMIT:MARKET; fillFixMessageStructure(cancelOrderTags, ref co); return(SendMessageToSession(co) ? cancelOrderTags[EFixTags.ClOrdID] : string.Empty); } else { return(string.Empty); } }
public virtual void fromAdmin(QuickFix.Message message, QuickFix.SessionID sessionID) { Console.WriteLine("fromAdmin: " + message); updateDisplay("fromAdmin: " + DateTime.Now.ToString("hh:mm:ss.fff")); crack(message, sessionID); }
public bool SENT_REJECT(int reason, int refTag) { if (!SENT_REJECT()) { return(false); } QuickFix.Message msg = responder.msgLookup[QuickFix.Fields.MsgType.REJECT].First(); if (!msg.IsSetField(QuickFix.Fields.Tags.SessionRejectReason)) { return(false); } QuickFix.Fields.SessionRejectReason reasonField = new QuickFix.Fields.SessionRejectReason(); msg.GetField(reasonField); if (reasonField.getValue() != reason) { return(false); } if (!msg.IsSetField(QuickFix.Fields.Tags.RefTagID)) { return(false); } QuickFix.Fields.RefTagID refTagField = new QuickFix.Fields.RefTagID(); msg.GetField(refTagField); if (refTagField.getValue() != refTag) { return(false); } return(true); }
public QuickFix.FixMessageDescriptor GetDescriptor() { try { QuickFix.Message msg = new QuickFix.Message(); msg.FromString(_message, false, null, null); string beginString = msg.Header.GetField(QuickFix.Fields.Tags.BeginString); QuickFix.DataDictionary.DataDictionary dict = _dicSource.GetDictionaryForBeginString(beginString); QuickFix.Message theMsg = new QuickFix.Message(); theMsg.FixMessageDescriptorEnabled = true; theMsg.FromString(_message, true, dict, dict); return theMsg.GetDescriptor(); } catch (Exception ex) { Trace.TraceError("{0}: Error while parsing fix message: {1}", this, ex); return null; } }
public IList <FixMesageValidationErrorDescriptor> GetValidationErrors() { try { QuickFix.Message msg = new QuickFix.Message(); msg.FromString(_message, false, null, null); string beginString = msg.Header.GetField(QuickFix.Fields.Tags.BeginString); string msgType = msgType = msg.Header.GetField(QuickFix.Fields.Tags.MsgType); QuickFix.DataDictionary.DataDictionary dict = _dicSource.GetDictionaryForBeginString(beginString); dict.Validate(msg, beginString, msgType); return(null); } catch (Exception ex) { //TODO: create a validation method on fix dictionary that retuns a list of errors instead of just throwing on the first one FixMesageValidationErrorDescriptor descr = new FixMesageValidationErrorDescriptor(); descr.Message = ex.Message; return(new List <FixMesageValidationErrorDescriptor>(new FixMesageValidationErrorDescriptor[] { descr })); } }
public void UnwrapMessage_AsMsgType_Ok_Sandbox() { // arrange var jsonFixMsg = new JsonFixMessageReceived { localPseudoHeader = "myPseudoHeader", messageTypeCode35 = "D", rawFixPayload = "8=FIX.4.2\u00019=00\u000135=D\u000149=Sender\u000156=Target\u000134=0\u000152=99990909-17:17:17.777\u000154=1\u000155=ABC\u000111=BUY000000001\u000138=1000\u000140=2\u000144=1001.000\u000159=3\u0001117=A001\u000146=A001\u000110=000\u0001" }; // act QuickFix.Message fixMsg = _jsonFixWrapper.Unwrap(jsonFixMsg); // QuickFix.FIX42.NewOrderSingle newOrderD = new QuickFix.FIX42.NewOrderSingle(); QuickFix.FIX42.NewOrderSingle newOrderD = _jsonFixWrapper.UnwrapAsType <NewOrderSingle>(jsonFixMsg); // issue how to downcast // assert var expectedTicker = "ABC"; var expectedTarget = "Target"; var actualTarget = newOrderD.Header.GetField(new QuickFix.Fields.TargetCompID()).getValue(); var actualTicker = newOrderD.Header.GetField(new QuickFix.Fields.Symbol()).getValue(); Assert.Equal(expectedTicker, actualTicker); Assert.Equal(expectedTarget, actualTarget); }
public new void crack(QuickFix.Message message, QuickFix.SessionID sessionID) { BeginString beginString = new BeginString(); message.getHeader().getField(beginString); crack(message, sessionID, beginString); }
public bool Send(string msgStr) { QuickFix.Fields.MsgType msgType = QuickFix.Message.IdentifyType(msgStr); string beginString = QuickFix.Message.ExtractBeginString(msgStr); QuickFix.Message message = messageFactory.Create(beginString, msgType.Obj); QuickFix.DataDictionary.DataDictionary dd = new QuickFix.DataDictionary.DataDictionary(); message.FromString(msgStr, false, dd, dd, _defaultMsgFactory); if (!msgLookup.ContainsKey(msgType.getValue())) { msgLookup.Add(msgType.getValue(), new Queue <QuickFix.Message>()); } msgLookup[msgType.getValue()].Enqueue(message); QuickFix.Fields.PossDupFlag possDup = new QuickFix.Fields.PossDupFlag(false); if (message.Header.IsSetField(possDup)) { message.Header.GetField(possDup); } if (possDup.getValue() && msgType.getValue() != QuickFix.Fields.MsgType.SEQUENCE_RESET) { dups.Enqueue(message); } return(true); }
public override bool HandleMessage(Message message) { var ack = message as CollateralInquiryAck; var pr = message as CollateralReport; if (ack == null && pr == null) { return(false); } var id = ack?.CollInquiryID.Obj ?? pr?.CollInquiryID.Obj; if (!Requests.TryGetValue(id, out var request)) { Log.WriteWarningAsync(nameof(HandleMessage), "Handle collateral report from Jfd", $"Received response with unknown id {id}").GetAwaiter().GetResult(); return(false); } if (ack != null) { request.ProcessResponse(ack); } else { request.ProcessResponse(pr); } if (request.Status == RequestStatus.Completed) { Requests.Remove(request.Id); } return(true); }
internal static void ReplicateFixMessage(QuickFix.Message msg) { try { lock (m_LockedObj) { string msgTypeString = msg.getHeader().getField(m_msgTypeTag); Guid[] subscribersKeys = GetFixMsgSubscribers(msgTypeString); if (subscribersKeys != null && subscribersKeys.Length > 0) { foreach (Guid key in subscribersKeys) { PushUpdates(new IReplicationResponse[] { new ReplicatedFixMsg() { ClientKey = key, FixMessage = msg.ToString(), ResponseDateTime = DateTime.Now, FixVersion = msg.getHeader().getField(m_fixMsgVersionTag) } }); } } } } catch (Exception ex) { Counters.IncrementCounter(CountersConstants.ExceptionMessages); SystemLogger.WriteOnConsoleAsync(true, string.Format("ReplicateFixMessage, Error: {0} ", ex.Message), ConsoleColor.Red, ConsoleColor.Black, true); } }
public static string PrettyPrint(this Message msg) { var fields = ListFields(msg); var str = string.Join("; ", from f in fields select $"{f.Name}={f.Value}"); return(str); }
private static IEnumerable <FixField> ListFields(Message msg) { var str = msg.ToString(); var parts = str.Split(new[] { '\x01' }, StringSplitOptions.RemoveEmptyEntries); foreach (var part in parts) { var i = part.IndexOf('='); if (i < 0) { continue; } var name = part.Substring(0, i); var value = part.Substring(i + 1); int.TryParse(name, out var tag); if (_Fields.TryGetValue(tag, out var tagName)) { name = tagName; } if (_FieldFormatters.TryGetValue(tag, out var formatter)) { value = formatter(value); } yield return(new FixField { Name = name, Value = value }); } }
public QuickFix.Message ReadNewOrderMultilegBytes() { var msg = new QuickFix.Message(); msg.FromString(newOrderMultilegBytes, true, dataDictionary, dataDictionary, msgFactory); return(msg); }
public QuickFix.Message ReadQuoteStatusRequestWithNestedGrp() { var msg = new QuickFix.Message(); msg.FromString(quoteStatusRequestWithNestedGrpsBytes, true, dataDictionary, dataDictionary, msgFactory); return(msg); }
public QuickFix.Message ReadMarketDataRequest() { var msg = new QuickFix.Message(); msg.FromString(marketDataRequestBytes, true, dataDictionary, dataDictionary, msgFactory); return(msg); }
public QuickFix.FixMessageDescriptor GetDescriptor() { try { QuickFix.Message msg = new QuickFix.Message(); msg.FromString(_message, false, null, null); string beginString = msg.Header.GetField(QuickFix.Fields.Tags.BeginString); QuickFix.DataDictionary.DataDictionary dict = _dicSource.GetDictionaryForBeginString(beginString); QuickFix.Message theMsg = new QuickFix.Message(); theMsg.FixMessageDescriptorEnabled = true; theMsg.FromString(_message, true, dict, dict); return(theMsg.GetDescriptor()); } catch (Exception ex) { Trace.TraceError("{0}: Error while parsing fix message: {1}", this, ex); return(null); } }
public virtual void fromApp(QuickFix.Message message, QuickFix.SessionID sessionID) { try { QuickFix.MsgType msgType = new QuickFix.MsgType(); message.getHeader().getField(msgType); string msgTypeValue = msgType.getValue(); log.WriteLog(string.Format("fromApp: {0}", msgTypeValue)); switch (msgTypeValue) { case "UAT": onGatewayStatusMessage((QuickFix42.Message)message, sessionID); break; case "UAP": onPositionReportMessage((QuickFix42.Message)message, sessionID); break; default: crack(message, sessionID); break; } } catch (QuickFix.UnsupportedMessageType umt) { log.WriteLog("UnsupportedMessageType: " + umt.Message); parseMessage(message, sessionID); } catch (Exception ex) { log.WriteLog(ex.ToString()); } }
public void ToApp(QuickFix.Message message, QuickFix.SessionID sessionId) { if (doNotSendException != null) { throw doNotSendException; } }
public IList<FixMesageValidationErrorDescriptor> GetValidationErrors() { try { QuickFix.Message msg = new QuickFix.Message(); msg.FromString(_message, false, null, null); string beginString = msg.Header.GetField(QuickFix.Fields.Tags.BeginString); string msgType = msgType = msg.Header.GetField(QuickFix.Fields.Tags.MsgType); QuickFix.DataDictionary.DataDictionary dict = _dicSource.GetDictionaryForBeginString(beginString); dict.Validate(msg, beginString, msgType); return null; } catch (Exception ex) { //TODO: create a validation method on fix dictionary that retuns a list of errors instead of just throwing on the first one FixMesageValidationErrorDescriptor descr = new FixMesageValidationErrorDescriptor(); descr.Message = ex.Message; return new List<FixMesageValidationErrorDescriptor>(new FixMesageValidationErrorDescriptor[] { descr }); } }
public void TestLastMsgSeqNumProcessed() { // Disabled by default Assert.That(!session.EnableLastMsgSeqNumProcessed); session.EnableLastMsgSeqNumProcessed = true; // Logon Logon(); QuickFix.Message msg = responder.msgLookup[QuickFix.Fields.MsgType.LOGON].Last(); int lastSeqNumProcessed = msg.Header.GetInt(QuickFix.Fields.Tags.LastMsgSeqNumProcessed); Assert.That(lastSeqNumProcessed == 1); // NOS QuickFix.FIX42.NewOrderSingle order = new QuickFix.FIX42.NewOrderSingle( new QuickFix.Fields.ClOrdID("1"), new QuickFix.Fields.HandlInst(QuickFix.Fields.HandlInst.MANUAL_ORDER), new QuickFix.Fields.Symbol("IBM"), new QuickFix.Fields.Side(QuickFix.Fields.Side.BUY), new QuickFix.Fields.TransactTime(), new QuickFix.Fields.OrdType(QuickFix.Fields.OrdType.LIMIT)); order.Header.SetField(new QuickFix.Fields.TargetCompID(sessionID.SenderCompID)); order.Header.SetField(new QuickFix.Fields.SenderCompID(sessionID.TargetCompID)); order.Header.SetField(new QuickFix.Fields.MsgSeqNum(seqNum++)); session.Send(order); msg = responder.msgLookup[QuickFix.Fields.MsgType.NEW_ORDER_D].Last(); lastSeqNumProcessed = msg.Header.GetInt(QuickFix.Fields.Tags.LastMsgSeqNumProcessed); Assert.That(lastSeqNumProcessed == 1); }
public void FromAdmin(QuickFix.Message message, QuickFix.SessionID sessionID) { if (fromAdminException != null) { throw fromAdminException; } }
public void AssertMicrosecondsInTag(string msgType, int tag, bool shouldHaveMicrosecond) { QuickFix.Message msg = responder.msgLookup[msgType].Last(); string sendingTime = msg.Header.GetString(tag); Match m = microsecondRegex.Match(sendingTime); Assert.That(m.Success == shouldHaveMicrosecond); }
private void SendTheMessage(QuickFix.Message msg) { msg.Header.SetField(new QuickFix.Fields.TargetCompID(sessionID.SenderCompID)); msg.Header.SetField(new QuickFix.Fields.SenderCompID(sessionID.TargetCompID)); msg.Header.SetField(new QuickFix.Fields.MsgSeqNum(seqNum++)); session.Next(msg.ToString()); }
public void ToApp(QuickFix.Message message, QuickFix.SessionID sessionId) { _strategy.ProcessToApp(message, QuickFix.Session.LookupSession(sessionId)); Trace.WriteLine("## ToApp: " + message.ToString()); if (MessageEvent != null) { MessageEvent(message, false); } }
public void FromApp(QuickFix.Message message, QuickFix.SessionID sessionID) { Trace.WriteLine("## FromApp: " + message.ToString()); if (MessageEvent != null) { MessageEvent(message, true); } Crack(message, sessionID); }
private void SendLogon(QuickFix.Message msg) { msg.Header.SetField(new QuickFix.Fields.TargetCompID(sessionID.SenderCompID)); msg.Header.SetField(new QuickFix.Fields.SenderCompID(sessionID.TargetCompID)); msg.Header.SetField(new QuickFix.Fields.MsgSeqNum(seqNum++)); msg.Header.SetField(new QuickFix.Fields.SendingTime(System.DateTime.UtcNow)); msg.SetField(new QuickFix.Fields.HeartBtInt(1)); session.Next(msg.ToString()); }
public override string ProcMarketOrder(ref bool comp, string symbol, string price, int qty) { QuickFix.Message sno = generateOrderMessage(symbol, price, qty, false); if (sno == null) { return(string.Empty); } return(SendMessageToSession(sno) ? sno.getField((int)EFixTags.ClOrdID) : string.Empty); }
/// <summary> /// Edit the order for the ID specified - throws an exception if the order isnt working /// </summary> /// <param name="myID"></param> /// <param name="newQty">new qty if specified</param> /// <param name="newPrice">new price if specified</param> public void ReplaceOrder(string myID, double? newQty, double? newPrice, double? newStopPx) { KaiTrade.Interfaces.Order myOrder = null; try { // Get Order KaiTrade.Interfaces.OrderManager myOM = AppFactory.Instance().GetOrderManager(); myOrder = myOM.GetOrder(myID); if (myOrder == null) { string myError = "Order not found cannot edit:" + myID; Exception myE = new Exception(myError); throw myE; } if (m_ORLog.IsInfoEnabled) { m_ORLog.Info("ReplaceOrder:"+ myOrder.ToString()); } // are these changes? if (!newValueDifferentFromOld(myOrder, newQty, newPrice, newStopPx)) { string myError = "The new fields in the Replace request are the same as the existing fields" + myID; Exception myE = new Exception(myError); throw myE; } // Is this a triggered order if (myOrder.TriggerOrderID.Length > 0) { if (newQty.HasValue) { myOrder.OrderQty = new QuickFix.OrderQty((double)newQty); } if (newPrice.HasValue) { myOrder.Price = new QuickFix.Price((double)newPrice); } if (newStopPx.HasValue) { myOrder.StopPx = new QuickFix.StopPx((double)newStopPx); } return; } // store the clordID's //NOT USED? QuickFix.OrigClOrdID myOrigClOrdID; QuickFix.ClOrdID myClOrdID; // check if we are pending cancel or pending mod if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.replace) { // we are currently doing a replace - cannot do another string myError = "Order is already processing a replace cannot modify at this time:" + myID; Exception myE = new Exception(myError); throw myE; } if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.cancel) { // we are currently doing a cancel - cannot do a mod string myError = "Order is already processing a cancel cannot modify" + myID; Exception myE = new Exception(myError); throw myE; } // check that the order is working if (!myOrder.IsWorking()) { if ((myOrder.OrdType.getValue() == QuickFix.OrdType.STOP) || (myOrder.OrdType.getValue() == QuickFix.OrdType.STOP_LIMIT)) { // no action } else { string myError = "Order is not in a working state cannot replace:" + myID; Exception myE = new Exception(myError); throw myE; } } // Check the limits for the order string myTextErr; double qty; if (newQty.HasValue) { qty = newQty.Value; } else { qty = myOrder.OrderQty.getValue(); } double px; if (newPrice.HasValue) { px = newPrice.Value; } else { px = myOrder.Price.getValue(); } if (LimitChecker.Instance().BreaksLimits(out myTextErr, myOrder, qty, px)) { myOrder.OrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.REJECTED); myOrder.Text = "You have exceeded the order qty limit - please re-enter"; Exception myE = new Exception("You have exceeded the order qty limit - please re-enter"); throw myE; } // Create a FIX cancel replace messsage QuickFix.Message myFixMsg = new QuickFix.Message(); QuickFix.MsgType msgType = new QuickFix.MsgType("G"); myFixMsg.getHeader().setField(msgType); QuickFix.BeginString myBeginString = new QuickFix.BeginString("FIX.4.4"); myFixMsg.getHeader().setField(myBeginString); // OrderID if (myOrder.OrderID == null) { myOrder.Text = "No order ID found cannot modify order"; Exception myE = new Exception("No order ID found cannot modify order"); throw myE; } // set the original to the existing clordid myOrder.OrigClOrdID = new QuickFix.OrigClOrdID(myOrder.ClOrdID.getValue()); myFixMsg.setField(myOrder.OrigClOrdID); myFixMsg.setField(myOrder.OrderID); ////Side myFixMsg.setField(myOrder.Side); // set up the product details in the message myOrder.Product.Set(myFixMsg); //// Transact Time myOrder.TransactTime = new QuickFix.TransactTime(DateTime.Now.ToUniversalTime()); myFixMsg.setField(myOrder.TransactTime); myFixMsg.setField(myOrder.OrdType); // Create the message wrapper used to send the order cancel to the driver KaiTrade.Interfaces.Message myMsg = new KaiTCPComm.KaiMessageWrap(); myMsg.Label = "G"; string myDriverCode = ""; // A trade venue must be specified on the order KaiTrade.Interfaces.Venue myVenue = null; if (myOrder.Product.TradeVenue.Length > 0) { // get the driver code and session details from the venue manager myVenue = AppFactory.Instance().GetVenueManager().GetVenue(myOrder.Product.TradeVenue); if (myVenue != null) { myDriverCode = myVenue.DriverCode; if (myVenue.TargetVenue.Length > 0) { myMsg.VenueCode = myVenue.TargetVenue; } if (myVenue.BeginString.Length > 0) { // this is the FIX version the server wants, we convert between // versions in the FIX client myMsg.Format = myVenue.BeginString; } if (myVenue.SID.Length > 0) { QuickFix.SenderCompID mySID = new QuickFix.SenderCompID(myVenue.SID); myFixMsg.getHeader().setField(mySID); myMsg.ClientID = myVenue.SID; } if (myVenue.TID.Length > 0) { QuickFix.TargetCompID myTID = new QuickFix.TargetCompID(myVenue.TID); myFixMsg.getHeader().setField(myTID); myMsg.TargetID = myVenue.TID; } } else { string myErr = "Invalid Venue Code:" + myOrder.Product.TradeVenue; m_Log.Error(myErr); Exception myE = new Exception(myErr); throw myE; } } else { string myErr = "No Venue Code specified on product:"; m_Log.Error(myErr); Exception myE = new Exception(myErr); throw myE; } // process any venue field bags - do this prior to the order bags // to allow the order setting to override the venues List<KaiTrade.Interfaces.Field> myFieldBag; KTAFacade.Instance().SetBag(out myFieldBag, myVenue.ReplaceBag, ","); foreach (KaiTrade.Interfaces.Field myField in myFieldBag) { try { myFixMsg.setString(int.Parse(myField.ID), myField.Value); } catch (Exception myE) { m_Log.Error("replace Extra tags from venue error:", myE); } } // process any additional tags for the order foreach (KaiTrade.Interfaces.Field myField in myOrder.ReplaceBag) { try { myFixMsg.setString(int.Parse(myField.ID), myField.Value); } catch (Exception myE) { m_Log.Error("replace Extra tags error:", myE); } } if (myOrder.Account != null) { if (myOrder.Account.getValue().Length > 0) { myFixMsg.setField(myOrder.Account); } } try { //Send the message KaiTrade.Interfaces.Driver myDrv = AppFactory.Instance().GetDriverManager().GetDriver(myDriverCode); if (myDrv != null) { // save the existing clordid and set the new clordid myClOrdID = myOrder.ClOrdID; myOrder.ClOrdID = new QuickFix.ClOrdID(KaiUtil.Identities.Instance.genReqID()); myFixMsg.setField(myOrder.ClOrdID); // Associate the CLOrdID with this order AppFactory.Instance().GetOrderManager().AssociateClOrdID(myOrder.ClOrdID.getValue(), myOrder); if (newQty.HasValue) { myOrder.OrderQty = new QuickFix.OrderQty((double)newQty); myFixMsg.setField(myOrder.OrderQty); } if (newPrice.HasValue) { myOrder.Price = new QuickFix.Price((double)newPrice); myFixMsg.setField(myOrder.Price); } if (newStopPx.HasValue) { myOrder.StopPx = new QuickFix.StopPx((double)newStopPx); myFixMsg.setField(myOrder.StopPx); } // Set the FIX string as message data myMsg.Data = myFixMsg.ToString(); // inform order manager clients that the order has changed myOM.SetChanged(myOrder.Identity); // send the message for processing //myDrv.Send(myMsg); // send the message for processing order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.replace; //SendDelegate mySend = new SendDelegate(myDrv.Send); //IAsyncResult ar = mySend.BeginInvoke(myMsg, SRCallback, "123456789"); myDrv.Send(myMsg); } else { string myError = "Driver not found for code:" + myDriverCode; m_Log.Error(myError); Exception myE = new Exception(myError); throw myE; } } catch (Exception myE) { m_Log.Error("EditOrder:Sendnessage part" + myOrder.Identity, myE); myOrder.OrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.REJECTED); throw (myE); } } catch (Exception myE) { m_Log.Error("ReplaceOrder:", myE); if (myOrder != null) { myOrder.OrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.REJECTED); myOrder.Text = myE.Message; } throw (myE); } }
/// <summary> /// Handle an incomming execution report /// </summary> /// <param name="myMsg"></param> public void HandleExecReport(KaiTrade.Interfaces.Message myMsg) { try { if (m_Log.IsInfoEnabled) { m_Log.Info("OrderService:HandleExecReport:" + myMsg.Data); } if (m_ORLog.IsInfoEnabled) { m_ORLog.Info("OrderService:HandleExecReport:" + myMsg.Data); } // Get order manager KaiTrade.Interfaces.OrderManager myOM = KTAFacade.Instance().Factory.GetOrderManager(); //Create a quickfix message object QuickFix.Message myFixMsg = new QuickFix.Message(myMsg.Data); QuickFix.ExecID myExecID = new QuickFix.ExecID(); myFixMsg.getField(myExecID); // check if we have already processed this report if (!myOM.RecordExecutionReport(myExecID.getValue(), myFixMsg)) { // we have processed this already m_Log.Warn("HandleExecReport: Duplicate Exec Report:" + myMsg.Data); return; } // these fields must be present QuickFix.OrderID myOrderID = new QuickFix.OrderID(); myFixMsg.getField(myOrderID); QuickFix.ExecType myExecType = new QuickFix.ExecType(); myFixMsg.getField(myExecType); QuickFix.OrdStatus myOrdStatus = new QuickFix.OrdStatus(); myFixMsg.getField(myOrdStatus); // we need the clordid to update an existing order - if // it is not present or unknow we create a synthetic order QuickFix.ClOrdID myClOrdID = new QuickFix.ClOrdID(); KaiTrade.Interfaces.Order myOrder = null; if (myFixMsg.isSetField(myClOrdID)) { myFixMsg.getField(myClOrdID); myOrder = myOM.GetOrderWithClOrdIDID(myClOrdID.getValue()); } if (myOrder == null) { myOrder = CreateSyntheticOrder(myFixMsg); } // add the ExecRep to the Order KaiTrade.Interfaces.Fill myFill = new K2DataObjects.FillData(); myFill.OrderID = myOrder.Identity; myFill.SetUpFromFixExecReport(myFixMsg.ToString()); myOrder.FillsList.Add(myFill); // update mandatory fields myOrder.OrderID = myOrderID; myOrder.OrdStatus = myOrdStatus; QuickFix.Text myText = new QuickFix.Text(); if (myFixMsg.isSetField(myText)) { myFixMsg.getField(myText); myOrder.Text = myText.getValue(); } QuickFix.Account myAccount = new QuickFix.Account(); if (myFixMsg.isSetField(myAccount)) { myFixMsg.getField(myAccount); myOrder.Account = myAccount; } // process the execution depanding on type of ExecReport switch (myExecType.getValue()) { case QuickFix.ExecType.NEW: processGeneralExecRep(ref myOrder, myFixMsg); /* if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.neworder) { order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none; } else { m_Log.Error("HandleExecReport:OrderStatus new not expected"); } * */ break; case QuickFix.ExecType.FILL: if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.neworder) { order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none; } processFill(ref myOrder, myFixMsg); break; case QuickFix.ExecType.PARTIAL_FILL: if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.neworder) { order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none; } processFill(ref myOrder, myFixMsg); break; case QuickFix.ExecType.ORDER_STATUS: processGeneralExecRep(ref myOrder, myFixMsg); break; default: processGeneralExecRep(ref myOrder, myFixMsg); break; } myOM.SetChanged(myOrder.Identity); // Check if the order is part of a strategy if (myOrder.ParentIdentity != null) { // get the strategy concerned KaiTrade.Interfaces.IStrategy myStrat = KTAFacade.Instance().Factory.GetStrategyManager().GetStrategy(myOrder.ParentIdentity); if (myStrat != null) { myStrat.HandleExecReport(myFixMsg, myOrder); } else { m_Log.Error("Strategy not found for:" + myOrder.ParentIdentity); } } if (myOrder.OCAGroupName.Length > 0) { KTAFacade.Instance().Factory.GetOCOManager().OnOrderTraded(myOrder); } if (m_ORLog.IsInfoEnabled) { m_ORLog.Info("OrderService:HandleExecRep:Exit:" + myOrder.ToString()); } } catch (Exception myE) { m_Log.Error("HandleExecReport", myE); } }
public void RenderOrderAsFix(out QuickFix.Message myNOS, out KaiTrade.Interfaces.Message myMsg, out string myDriverCode, KaiTrade.Interfaces.Order myOrder) { try { lock (this) { // do not actually submit triggered orders // register the order as a publisher KaiTrade.Interfaces.Publisher myPub = null; myPub = AppFactory.Instance().GetPublisherManager().GetPublisher(myOrder.Identity); if (myPub == null) { myPub = myOrder as KaiTrade.Interfaces.Publisher; AppFactory.Instance().GetPublisherManager().Add(myPub); } // Check the limits for the order string myTextErr; if (LimitChecker.Instance().BreaksLimits(out myTextErr, myOrder)) { myOrder.OrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.REJECTED); myOrder.Text = "order failed order qty limit test"; Exception myE = new Exception("process order failed order qty limit test"); throw myE; } // Create the FIX order message myNOS = new QuickFix.Message(); // pending new at this stage myOrder.OrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.PENDING_NEW); myOrder.TransactTime = new QuickFix.TransactTime(DateTime.Now.ToUniversalTime()); myNOS.setField(myOrder.TransactTime); //myOrder.ClOrdID = new QuickFix.ClOrdID(KaiUtil.Identities.Instance.genReqID()); // Associate the CLOrdID with this order AppFactory.Instance().GetOrderManager().AssociateClOrdID(myOrder.ClOrdID.getValue(), myOrder); // Set fix version QuickFix.BeginString myBeginString = new QuickFix.BeginString("FIX.4.4"); myNOS.getHeader().setField(myBeginString); // Set order message type QuickFix.MsgType msgType = new QuickFix.MsgType(); msgType.setValue("D"); myNOS.getHeader().setField(msgType); myNOS.setField(myOrder.ClOrdID); // set up the product details in the message myOrder.Product.Set(myNOS); // Qty myNOS.setField(myOrder.OrderQty); // MaxFloor if (myOrder.MaxFloor != null) { myNOS.setField(myOrder.MaxFloor); } // set the side myNOS.setField(myOrder.Side); // set the order type myNOS.setField(myOrder.OrdType); // Time in force if (myOrder.TimeInForce != null) { myNOS.setField(myOrder.TimeInForce); } else { myOrder.TimeInForce = new QuickFix.TimeInForce(QuickFix.TimeInForce.DAY); myNOS.setField(myOrder.TimeInForce); } // Validation - check they entered a date/time if needed switch (myOrder.TimeInForce.getValue()) { case QuickFix.TimeInForce.GOOD_TILL_DATE: break; default: break; } // do not add the price to the fix message on Market orders if (myOrder.OrdType.getValue() != QuickFix.OrdType.MARKET) { if (myOrder.Price.getValue() > 0) { myNOS.setField(myOrder.Price); } else { throw new Exception("Must specify price > 0 on Limit and other non Market orders"); } } if (myOrder.StopPx != null) { myNOS.setField(myOrder.StopPx); } // default the handlInst to automated if (myOrder.HandlInst != null) { myNOS.setField(myOrder.HandlInst); } else { myOrder.HandlInst = new QuickFix.HandlInst(QuickFix.HandlInst.AUTOEXECPUB); myNOS.setField(myOrder.HandlInst); } // Create the message wrapper used to send the order to the driver myMsg = new KaiTCPComm.KaiMessageWrap(); myMsg.Label = "D"; myDriverCode = ""; // A trade venue must be specified on the order KaiTrade.Interfaces.Venue myVenue = null; if (myOrder.Product.TradeVenue.Length > 0) { // get the driver code and session details from the venue manager myVenue = AppFactory.Instance().GetVenueManager().GetVenue(myOrder.Product.TradeVenue); if (myVenue != null) { myDriverCode = myVenue.DriverCode; if (myVenue.TargetVenue.Length > 0) { myMsg.VenueCode = myVenue.TargetVenue; } if (myVenue.BeginString.Length > 0) { // this is the FIX version the server wants, we convert between // versions in the FIX client myMsg.Format = myVenue.BeginString; } if (myVenue.SID.Length > 0) { QuickFix.SenderCompID mySID = new QuickFix.SenderCompID(myVenue.SID); myNOS.getHeader().setField(mySID); myMsg.ClientID = myVenue.SID; } if (myVenue.TID.Length > 0) { QuickFix.TargetCompID myTID = new QuickFix.TargetCompID(myVenue.TID); myNOS.getHeader().setField(myTID); myMsg.TargetID = myVenue.TID; } } else { string myErr = "Invalid Venue Code:" + myOrder.Product.TradeVenue; m_Log.Error(myErr); Exception myE = new Exception(myErr); throw myE; } } else { string myErr = "No Venue Code specified on product:"; m_Log.Error(myErr); Exception myE = new Exception(myErr); throw myE; } // process any venue field bags - do this prior to the order bags // to allow the order setting to override the venues List<KaiTrade.Interfaces.Field> myFieldBag; KTAFacade.Instance().SetBag(out myFieldBag, myVenue.NOSBag, ","); foreach (KaiTrade.Interfaces.Field myField in myFieldBag) { try { myNOS.setString(int.Parse(myField.ID), myField.Value); } catch (Exception myE) { m_Log.Error("NOS Extra tags from venue error:", myE); } } // process any additional tags for the order foreach (KaiTrade.Interfaces.Field myField in myOrder.NOSBag) { try { myNOS.setString(int.Parse(myField.ID), myField.Value); } catch (Exception myE) { m_Log.Error("NOS Extra tags error:", myE); } } // additional setting placed here will override the // fields in the bags if (myOrder.Account != null) { if (myOrder.Account.getValue().Length > 0) { myNOS.setField(myOrder.Account); } } QuickFix.TargetStrategyParameters targetStrategyParameters = new QuickFix.TargetStrategyParameters(myOrder.StrategyName); myNOS.setField(targetStrategyParameters); // Process any strategy parameters if (myOrder.K2Parameters.Count > 0) { QuickFix.NoStrategyParameters noStratParms = new QuickFix.NoStrategyParameters(myOrder.K2Parameters.Count); myNOS.setField(noStratParms); QuickFix50Sp2.NewOrderSingle.NoStrategyParameters group = new QuickFix50Sp2.NewOrderSingle.NoStrategyParameters(); QuickFix.StrategyParameterName strategyParameterName; QuickFix.StrategyParameterType strategyParameterType; QuickFix.StrategyParameterValue strategyParameterValue; foreach (KaiTrade.Interfaces.K2Parameter param in myOrder.K2Parameters) { strategyParameterName = new QuickFix.StrategyParameterName(param.ParameterName); group.setField(strategyParameterName); strategyParameterType = new QuickFix.StrategyParameterType((int)param.ParameterType); group.setField(strategyParameterType); strategyParameterValue = new QuickFix.StrategyParameterValue(param.ParameterValue); group.setField(strategyParameterValue); myNOS.addGroup(group); } } // Set the FIX string as message data myMsg.Data = myNOS.ToString(); // inform order manager clients that the order has changed AppFactory.Instance().GetOrderManager().SetChanged(myOrder.Identity); } } catch (Exception myE) { m_Log.Error("RenderOrderAsFix:", myE); myOrder.OrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.REJECTED); myOrder.Text = myE.Message; // inform order manager clients that the order has changed AppFactory.Instance().GetOrderManager().SetChanged(myOrder.Identity); throw (myE); } }
/// <summary> /// submit an order to IB using a incomming FIX new order single /// </summary> /// <param name="myMsg"></param> private void submitOrder(KaiTrade.Interfaces.IMessage myMsg) { QuickFix.Message myQFOrder = null; try { // Extract the raw FIX Message from the inbound message string strOrder = myMsg.Data; // Use QuickFix to handle the message myQFOrder = new QuickFix.Message(strOrder); // Use product manager to validate the product specified on // the order exists for this adapter // Get the product associated with the FIX message //QuickFix.Symbol symbol = new QuickFix.Symbol(); //myQFOrder.getField(symbol); QuickFix.Side mySide = new QuickFix.Side(); QuickFix.OrdType myOrdType = new QuickFix.OrdType(); QuickFix.OrderQty myOrderQty = new QuickFix.OrderQty(); QuickFix.Price myPrice = new QuickFix.Price(); QuickFix.StopPx myStopPx = new QuickFix.StopPx(); QuickFix.Account myAccount = new QuickFix.Account(); QuickFix.ClOrdID myClOrdID = new QuickFix.ClOrdID(); QuickFix.TimeInForce myTimeInForce = new QuickFix.TimeInForce(); // the account code is mandatory if (myQFOrder.isSetField(myAccount)) { myQFOrder.getField(myAccount); } else { this.SendAdvisoryMessage("IB TWS: you need to provide a valid account"); throw new Exception("IB TWS: you need to provide a valid account"); } myQFOrder.getField(myClOrdID); // Get the Order type myQFOrder.getField(myOrdType); // Get the QTY myQFOrder.getField(myOrderQty); // get the Side of the order myQFOrder.getField(mySide); // Set order duration myQFOrder.getField(myTimeInForce); // Prices if (myQFOrder.isSetField(myPrice)) { myQFOrder.getField(myPrice); } if (myQFOrder.isSetField(myStopPx)) { myQFOrder.getField(myStopPx); } // get the contract TWSLib.IContract myContract = getIBContract(myQFOrder); if (myContract == null) { this.SendAdvisoryMessage("IB TWS: cannot find a valid contract"); throw new Exception("IB TWS: cannot find a valid contract"); } // create an IB Order TWSLib.IOrder myIBOrder = m_Host.TWS.createOrder(); myIBOrder.whatIf = 0; myIBOrder.account = myAccount.getValue(); if(myOrdType.getValue() == QuickFix.OrdType.LIMIT) { myIBOrder.orderType = "LMT"; myIBOrder.lmtPrice = myPrice.getValue(); } else if(myOrdType.getValue() == QuickFix.OrdType.MARKET) { myIBOrder.orderType = "MKT"; } else if (myOrdType.getValue() == QuickFix.OrdType.STOP) { myIBOrder.orderType = "STP"; myIBOrder.auxPrice = myStopPx.getValue(); if (myPrice.getValue() == -1) { myIBOrder.lmtPrice = myStopPx.getValue(); } else { myIBOrder.lmtPrice = myPrice.getValue(); } } else if (myOrdType.getValue() == QuickFix.OrdType.STOP_LIMIT) { myIBOrder.orderType = "STP"; myIBOrder.auxPrice = myStopPx.getValue(); if (myPrice.getValue() == -1) { myIBOrder.lmtPrice = myStopPx.getValue(); } else { myIBOrder.lmtPrice = myPrice.getValue(); } } else { this.SendAdvisoryMessage("IB TWS: order type not supported"); throw new Exception("IB TWS: order type not supported"); } myIBOrder.totalQuantity = (int) myOrderQty.getValue(); // Side string myAction = KaiUtil.QFUtils.DecodeSide(mySide).ToUpper(); myIBOrder.action = myAction; // Time in force string myTIF = KaiUtil.QFUtils.DecodeTimeInForce(myTimeInForce).ToUpper(); myIBOrder.timeInForce = myTIF; if (myOrdType.getValue() == QuickFix.OrdType.LIMIT) { myIBOrder.lmtPrice = myPrice.getValue(); } DriverBase.OrderContext myCntx = RecordOrderContext(myClOrdID.getValue(), myQFOrder, null, m_NextID.ToString()); SetContextCommand(myCntx, DriverBase.ORCommand.Undefined, DriverBase.ORCommand.Submit); myCntx.OrderQty = myIBOrder.totalQuantity; myCntx.CumQty = 0; m_Host.TWS.placeOrderEx(m_NextID++, myContract, myIBOrder); } catch (Exception myE) { _log.Error("submitOrder", myE); // To provide the end user with more information // send an advisory message, again this is optional // and depends on the adpater this.SendAdvisoryMessage("IB TWS:submitOrder: problem submitting order:" + myE.ToString()); QuickFix.OrdStatus myOrdStatus; QuickFix.ExecType myExecType = new QuickFix.ExecType(QuickFix.ExecType.REJECTED); myOrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.REJECTED); QuickFix.OrderQty orderQty = new QuickFix.OrderQty(); if (myQFOrder != null) { myQFOrder.getField(orderQty); QuickFix.OrdRejReason myRejReason = new QuickFix.OrdRejReason(QuickFix.OrdRejReason.OTHER); sendExecReport(myQFOrder, new QuickFix.OrderID("UNKNOWN"), myOrdStatus, myExecType, 0.0, (int)orderQty.getValue(), 0, 0, 0, myE.Message, myRejReason); } } }
/// <summary> /// Cancel the order specified /// </summary> /// <param name="myID">ID of order to cancel</param> public void CancelOrder(string myID) { try { // Get Order KaiTrade.Interfaces.OrderManager myOM = AppFactory.Instance().GetOrderManager(); KaiTrade.Interfaces.Order myOrder = myOM.GetOrder(myID); if (myOrder == null) { string myError = "Order not found cannot cancel:" + myID; Exception myE = new Exception(myError); } if (m_ORLog.IsInfoEnabled) { m_ORLog.Info("CancelOrder:" + myOrder.ToString()); } if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.cancel) { string myError = "Order has already had a cancel processed - cannot recancel:" + myID; Exception myE = new Exception(myError); } // Is this a triggered order if (myOrder.TriggerOrderID.Length > 0) { KaiTrade.Interfaces.TriggeredOrder triggeredOrder = KTAFacade.Instance().Factory.GetTriggeredOrderManager().Get(myOrder.TriggerOrderID); triggeredOrder.Cancel(); return; } // store the clordID's //NOT USED? QuickFix.OrigClOrdID myOrigClOrdID; QuickFix.ClOrdID myClOrdID; if ((myOrder.OrdStatus.getValue() == QuickFix.OrdStatus.FILLED) || (myOrder.OrdStatus.getValue() == QuickFix.OrdStatus.CANCELED)) { // cannot cancel the order - so return return; } // Create a FIX cancel messsage QuickFix.Message myFixMsg = new QuickFix.Message(); QuickFix.MsgType msgType = new QuickFix.MsgType("F"); myFixMsg.getHeader().setField(msgType); QuickFix.BeginString myBeginString = new QuickFix.BeginString("FIX.4.4"); myFixMsg.getHeader().setField(myBeginString); // set the original to the existing clordid myOrder.OrigClOrdID = new QuickFix.OrigClOrdID(myOrder.ClOrdID.getValue()); myFixMsg.setField(myOrder.OrigClOrdID); // save the existing clordid and set the new clordid myClOrdID = myOrder.ClOrdID; myOrder.ClOrdID = new QuickFix.ClOrdID(KaiUtil.Identities.Instance.genReqID()); myFixMsg.setField(myOrder.ClOrdID); // Associate the CLOrdID with this order AppFactory.Instance().GetOrderManager().AssociateClOrdID(myOrder.ClOrdID.getValue(), myOrder); // OrderID if (myOrder.OrderID != null) { myFixMsg.setField(myOrder.OrderID); } ////Side myFixMsg.setField(myOrder.Side); // set up the product details in the message myOrder.Product.Set(myFixMsg); //// Transact Time myOrder.TransactTime = new QuickFix.TransactTime(DateTime.Now.ToUniversalTime()); myFixMsg.setField(myOrder.TransactTime); // Create the message wrapper used to send the order cancel to the driver KaiTrade.Interfaces.Message myMsg = new KaiTCPComm.KaiMessageWrap(); myMsg.Label = "F"; string myDriverCode = ""; // A trade venue must be specified on the order KaiTrade.Interfaces.Venue myVenue = null; if (myOrder.Product.TradeVenue.Length > 0) { // get the driver code and session details from the venue manager myVenue = AppFactory.Instance().GetVenueManager().GetVenue(myOrder.Product.TradeVenue); if (myVenue != null) { myDriverCode = myVenue.DriverCode; if (myVenue.TargetVenue.Length > 0) { myMsg.VenueCode = myVenue.TargetVenue; } if (myVenue.BeginString.Length > 0) { // this is the FIX version the server wants, we convert between // versions in the FIX client myMsg.Format = myVenue.BeginString; } if (myVenue.SID.Length > 0) { QuickFix.SenderCompID mySID = new QuickFix.SenderCompID(myVenue.SID); myFixMsg.getHeader().setField(mySID); myMsg.ClientID = myVenue.SID; } if (myVenue.TID.Length > 0) { QuickFix.TargetCompID myTID = new QuickFix.TargetCompID(myVenue.TID); myFixMsg.getHeader().setField(myTID); myMsg.TargetID = myVenue.TID; } } else { string myErr = "Invalid Venue Code:" + myOrder.Product.TradeVenue; m_Log.Error(myErr); Exception myE = new Exception(myErr); throw myE; } } else { string myErr = "No Venue Code specified on product:"; m_Log.Error(myErr); Exception myE = new Exception(myErr); throw myE; } // process any venue field bags - do this prior to the order bags // to allow the order setting to override the venues List<KaiTrade.Interfaces.Field> myFieldBag; KTAFacade.Instance().SetBag(out myFieldBag, myVenue.CancelBag, ","); foreach (KaiTrade.Interfaces.Field myField in myFieldBag) { try { myFixMsg.setString(int.Parse(myField.ID), myField.Value); } catch (Exception myE) { m_Log.Error("cancel Extra tags from venue error:", myE); } } // process any additional tags for the order foreach (KaiTrade.Interfaces.Field myField in myOrder.CancelBag) { try { myFixMsg.setString(int.Parse(myField.ID), myField.Value); } catch (Exception myE) { m_Log.Error("cancel Extra tags error:", myE); } } if (myOrder.Account != null) { if (myOrder.Account.getValue().Length > 0) { myFixMsg.setField(myOrder.Account); } } // Set the FIX string as message data myMsg.Data = myFixMsg.ToString(); // inform order manager clients that the order has changed myOM.SetChanged(myOrder.Identity); try { //Send the message KaiTrade.Interfaces.Driver myDrv = AppFactory.Instance().GetDriverManager().GetDriver(myDriverCode); if (myDrv != null) { // send the message for processing order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.cancel; //SendDelegate mySend = new SendDelegate(myDrv.Send); //IAsyncResult ar = mySend.BeginInvoke(myMsg, SRCallback, "123456789"); // send the message for processing myDrv.Send(myMsg); } else { string myError = "Driver not found for code:" + myDriverCode; m_Log.Error(myError); Exception myE = new Exception(myError); throw myE; } } catch (Exception myE) { m_Log.Error("CanceltOrder:" + myOrder.Identity, myE); myOrder.OrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.REJECTED); order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none; throw (myE); } } catch (Exception myE) { m_Log.Error("CancelOrder:", myE); throw (myE); } }