示例#1
0
        internal static TransactionBookData ToTransactionBookData(XmlNode tranNode)
        {
            string tranCode = string.Empty;
            Guid?  orderBatchInstructionId;
            TransactionBookData tranData = TransactionParser.ParseTransactionBookData(tranNode, out orderBatchInstructionId);

            tranData.Id     = Guid.Parse(tranNode.Attributes["ID"].Value);
            tranData.Orders = new List <OrderBookData>();

            var instrument = InstrumentManager.Default.Get(tranData.InstrumentId);
            InstrumentCategory instrumentCategory = instrument.Category;

            foreach (XmlNode orderNode in tranNode.ChildNodes)
            {
                if (orderNode.Name == "Order")
                {
                    OrderBookData orderData = null;
                    if (instrumentCategory == InstrumentCategory.Forex)
                    {
                        orderData = OrderDataHelper.InitializeBookData(orderNode);
                    }
                    else
                    {
                        orderData = OrderDataHelper.InitalizePhysicalBookData(orderNode);
                    }
                    orderData.OrderBatchInstructionID = orderBatchInstructionId;
                    tranData.Orders.Add(orderData);
                }
            }
            tranData.PlaceByRiskMonitor = true;
            return(tranData);
        }
        public void ReadOrderBookFile(string fileName)
        {
            string allText = System.IO.File.ReadAllText(fileName);
            int    index   = allText.IndexOf('{');

            orderBookData = System.Text.Json.JsonSerializer.Deserialize <OrderBookData>(allText.Substring(index));
        }
示例#3
0
        public static OrderBookDepth ParseOrderBookDepth(string data, int limit)
        {
            /*
             * {
             * "result": {
             *     "asks": [[8474.0, 2.5738], [8476.5, 2.6028]],
             *     "bids": [[8473.5, 1.1804], [8473.0, 73.913]]
             * },
             * "success": true
             * }
             */

            var token    = ParserHelpers.Parse(data);
            var errorRes = ParseErrors(token);

            if (errorRes.ErrorAvaliable)
            {
                return(new OrderBookDepth(errorRes.Message, errorRes.Code));
            }

            token = token["result"];
            var asks = new OrderBookData[limit];
            var bids = new OrderBookData[limit];

            var askToken = token["asks"];
            var bidToken = token["bids"];

            int counter = 0;

            foreach (var ask in askToken)
            {
                var p = ParserHelpers.ParseDecimal(ask[0]);
                var a = ParserHelpers.ParseDecimal(ask[1]);

                asks[counter] = new OrderBookData(p, a);
                counter++;
            }

            counter = 0;
            foreach (var bid in bidToken)
            {
                var p = ParserHelpers.ParseDecimal(bid[0]);
                var a = ParserHelpers.ParseDecimal(bid[1]);

                bids[counter] = new OrderBookData(p, a);
                counter++;
            }

            return(new OrderBookDepth(bids, asks));
        }
 private void OrderBookHandler(OrderBookData data)
 {
     if (!TrackedSymbol.Equals(data.Symbol))
     {
         return;
     }
     SpotPrice         = data.MarkPrice;
     LastTradePrice    = data.LastTradePrice;
     LastTradeQuantity = data.LastTradeQuantity;
     Asks = new ConcurrentDictionary <decimal, decimal>(data.Asks);
     Bids = new ConcurrentDictionary <decimal, decimal>(data.Bids);
     LastFullUpdateTimestamp = DateTime.Now;
     OrderBookUpdated?.Invoke(this);
 }
 protected override OrderBLL.Commands.AddOrderCommandBase CreateAddOrderCommand(OrderBLL.Factory.AddOrderCommandFactoryBase factory, Transaction tran, OrderBookData orderData, DateTime tradeDay)
 {
     return(factory.CreateBookOrder(tran, orderData, tradeDay));
 }