Example #1
0
      public void fromApp(QuickFix.Message message, SessionID sessionID)
      {
          // receiving messages
          Symbol sym = new Symbol();
          message.getField(sym);
          Tick k = new TickImpl(sym.getValue());
	
	{
          // bid
          BidPx bp = new BidPx();
          BidSize bs = new BidSize();
          k.bid = (decimal)bp.getValue();
          k.bs = (int)message.getField(bs).getValue();
	}
	
	{
          // ask
          OfferPx op = new OfferPx();
          OfferSize os = new OfferSize();
          k.ask = (decimal)op.getValue();
          k.os = (int)message.getField(os).getValue();
	}
	
	{
          // last
          Price price = new Price();
          message.getField(price);
          k.trade = (decimal)price.getValue();
	}
	
          tl.newTick(k);
          //ClOrdID clOrdID = new ClOrdID();
          //message.getField(clOrdID);
      }
Example #2
0
        /// <summary>
        /// Process general purpose exec i.e. some type of order status change
        /// </summary>
        /// <param name="myOrder"></param>
        /// <param name="myExec"></param>
        private void processGeneralExecRep(ref KaiTrade.Interfaces.Order myOrder, QuickFix.Message myExec)
        {
            if (m_ORLog.IsInfoEnabled)
            {
                m_ORLog.Info("processGeneralExecRep:");
            }
            QuickFix.OrdStatus myOrdStatus = new QuickFix.OrdStatus();
            QuickFix.LeavesQty myLeavesQty = new QuickFix.LeavesQty();
            QuickFix.CumQty myCumQty = new QuickFix.CumQty();
            myExec.getField(myOrdStatus);
            myOrder.OrdStatus = myOrdStatus;

            switch (myOrdStatus.getValue())
            {
                case QuickFix.OrdStatus.CANCELED:
                    if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.cancel)
                    {
                        order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
                    }

                    myLeavesQty = new QuickFix.LeavesQty(0.0);
                    myOrder.LeavesQty = myLeavesQty;
                    break;
                case QuickFix.OrdStatus.NEW:

                    if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.neworder)
                    {
                        order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
                    }
                    else if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.replace)
                    {
                        order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
                    }
                    else
                    {
                        m_Log.Error("HandleExecReport:OrderStatus new not expected");
                    }
                    myOrder.LeavesQty  = new QuickFix.LeavesQty(myOrder.OrderQty.getValue());
                    myOrder.CumQty = new QuickFix.CumQty(0.0);
                    break;
                case QuickFix.OrdStatus.REPLACED:
                    if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.replace)
                    {
                        order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
                    }
                    if (myExec.isSetField(myLeavesQty))
                    {
                        myExec.getField(myLeavesQty);
                        myOrder.LeavesQty = myLeavesQty;
                    }
                    if (myExec.isSetField(myCumQty))
                    {
                        myExec.getField(myCumQty);
                        myOrder.CumQty = myCumQty;
                    }

                    break;
                case QuickFix.OrdStatus.PENDING_REPLACE:
                    if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.replace)
                    {
                        m_ORLog.Error("Pending replace received but last command is not replace");
                    }

                    break;
                case QuickFix.OrdStatus.REJECTED:
                    if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.cancel)
                    {
                        order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
                    }
                    else if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.neworder)
                    {
                        order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
                    }
                    else if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.replace)
                    {
                        order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
                    }
                    break;
                default:
                    break;
            }
        }
Example #3
0
        /// <summary>
        /// Create a synthetic order
        /// </summary>
        /// <param name="myMsg"></param>
        /// <returns>n order</returns>
        public KaiTrade.Interfaces.Order CreateSyntheticOrder(QuickFix.Message myFixMsg)
        {
            KaiTrade.Interfaces.Order myOrder = null;
            try
            {
                if (m_Log.IsInfoEnabled)
                {
                    m_Log.Info("exec report recd:" + myFixMsg.ToString());
                }

                // Get order manager
                KaiTrade.Interfaces.OrderManager myOM = KTAFacade.Instance().Factory.GetOrderManager();

                // these fields must be present
                QuickFix.OrderID myOrderID = new QuickFix.OrderID();
                myFixMsg.getField(myOrderID);

                QuickFix.ExecType myExecType = new QuickFix.ExecType();
                myFixMsg.getField(myExecType);

                QuickFix.ExecID myExecID = new QuickFix.ExecID();
                myFixMsg.getField(myExecID);

                QuickFix.OrdStatus myOrdStatus = new QuickFix.OrdStatus();
                myFixMsg.getField(myOrdStatus);

                // Create the order
                myOrder = myOM.CreateOrder();

                // 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();
                if (myFixMsg.isSetField(myClOrdID))
                {
                    myOrder.ClOrdID = myClOrdID;
                }
            }
            catch (Exception myE)
            {
                m_Log.Error("CreateSyntheticOrder", myE);
            }
            return myOrder;
        }
Example #4
0
        /// <summary>
        /// Process partial or fully filled
        /// </summary>
        /// <param name="myOrder"></param>
        /// <param name="myExec"></param>
        private void processFill(ref KaiTrade.Interfaces.Order myOrder, QuickFix.Message myExec)
        {
            K2ServiceInterface.ITransaction myTrn = null;
            try
            {
                // if the object supports transactions do the update as a trn
                myTrn = myOrder as K2ServiceInterface.ITransaction;
                if (myTrn != null)
                {
                    myTrn.StartUpdate();
                }
                // Get the currently executed quantity for chain of orders.
                QuickFix.CumQty myCumQty = new QuickFix.CumQty();
                myExec.getField(myCumQty);
                myOrder.CumQty = myCumQty;

                // Get quantity open for further execution (order qty - cum qty)
                QuickFix.LeavesQty myLeavesQty = new QuickFix.LeavesQty();
                myExec.getField(myLeavesQty);
                myOrder.LeavesQty = myLeavesQty;

                QuickFix.LastPx myLastPx = new QuickFix.LastPx();
                if (myExec.isSetField(myLastPx))
                {
                    myExec.getField(myLastPx);
                    myOrder.LastPx = myLastPx;
                }

                QuickFix.AvgPx myAvgPx = new QuickFix.AvgPx();
                if (myExec.isSetField(myAvgPx))
                {
                    myExec.getField(myAvgPx);
                    myOrder.AvgPx = myAvgPx;
                }

                QuickFix.LastQty myLastQty = new QuickFix.LastQty();
                if (myExec.isSetField(myLastQty))
                {
                    myExec.getField(myLastQty);
                    myOrder.LastQty = myLastQty;
                }

                QuickFix.OrdStatus myOrdStatus = new QuickFix.OrdStatus();
                myExec.getField(myOrdStatus);
                myOrder.OrdStatus = myOrdStatus;
                // always signal the end of the update
                if (myTrn != null)
                {
                    myTrn.EndUpdate();
                }
            }
            catch (Exception myE)
            {
                m_Log.Error("processFill", myE);
                // always signal the end of the update
                if (myTrn != null)
                {
                    myTrn.EndUpdate();
                }
            }
        }