コード例 #1
0
        private void PublishOrdersAfterReplay()
        {
            string currencyPair = "XBTUSD";
            Order  order1       = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 100, 406, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order1));
            Order order2 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 101, 406, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order2));
            Order order3 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 102, 405, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order3));
            Order order4 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 100, 407, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order4));
            Order order5 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 104, 409, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order5));
            Order order6 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 104, 413, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order6));
            ManualResetEvent resetEvent = new ManualResetEvent(false);

            resetEvent.WaitOne(10000);
        }
コード例 #2
0
        private void Scenario1()
        {
            string currencyPair = "XBTUSD";
            Order  order1       = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 100, 400, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order1));
            Order order2 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 101, 401, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order2));
            Order order3 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 102, 402, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order3));
            Order order4 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 103, 403, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order4));
            Order order5 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 104, 404, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order5));
            Order order6 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 105, 405, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order6));
            Order order7 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 106, 406, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order7));
            Order order8 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 100, 410, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order8));
            Order order9 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 101, 409, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order9));
            Order order10 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 102, 407, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order10));
            Order order11 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 103, 406, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order11));
            Order order12 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 104, 405, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order12));
            Order order13 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 105, 411, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order13));
            Order order14 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 106, 412, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order14));
            Order order15 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 107, 400, new StubbedOrderIdGenerator());

            InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order15));
            ManualResetEvent resetEvent = new ManualResetEvent(false);

            resetEvent.WaitOne(20000);
        }
コード例 #3
0
        public void CreateAndLogOrder_GetAllTheOrdersBackFromTheEventStore_CheckIfOrderIsRetreivedProperly()
        {
            Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
                                                   new StubbedOrderIdGenerator());
            InputPayload payload = InputPayload.CreatePayload(order);

            InputDisruptorPublisher.Publish(payload);
            _manualResetEvent.WaitOne(5000);
            //retrieve order
            Order savedOrder = _eventStore.GetEvent(order.OrderId.Id.ToString()) as Order;

            Assert.NotNull(savedOrder);
            Assert.AreEqual(savedOrder, order);
        }
コード例 #4
0
        public void CreateOrder_PublishToInputDisruptor_JournalerShouldSaveTheEvent()
        {
            Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
                                                   new StubbedOrderIdGenerator());
            InputPayload payload = InputPayload.CreatePayload(order);

            InputDisruptorPublisher.Publish(payload);
            _manualResetEvent.WaitOne(5000);
            //retrieve order
            Order savedOrder = _eventStore.GetEvent(order.OrderId.Id.ToString()) as Order;

            Assert.NotNull(savedOrder);
            Assert.AreEqual(savedOrder, order);
        }
コード例 #5
0
        public NewOrderRepresentation CreateOrder(CreateOrderCommand orderCommand)
        {
            IOrderIdGenerator orderIdGenerator = ContextRegistry.GetContext()["OrderIdGenerator"] as IOrderIdGenerator;

            Tuple <string, string> splittedCurrencyPairs = CurrencySplitterService.SplitCurrencyPair(orderCommand.Pair);

            Order order = OrderFactory.CreateOrder(orderCommand.TraderId, orderCommand.Pair,
                                                   orderCommand.Type, orderCommand.Side, orderCommand.Volume, orderCommand.Price, orderIdGenerator);

            if (_balanceValidationService.FundsConfirmation(order.TraderId.Id, splittedCurrencyPairs.Item1,
                                                            splittedCurrencyPairs.Item2, order.Volume.Value, order.Price.Value, order.OrderSide.ToString(),
                                                            order.OrderId.Id))
            {
                InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order));
                return(new NewOrderRepresentation(order));
            }
            throw new InvalidOperationException("Not Enough Balance for Trader with ID: " + orderCommand.TraderId);
        }
コード例 #6
0
 public CancelOrderResponse CancelOrder(CancelOrderCommand cancelOrderCommand)
 {
     try
     {
         // Verify cancel order command
         if (_commandValidationService.ValidateCancelOrderCommand(cancelOrderCommand))
         {
             string            currencyPair = _commandValidationService.GetCurrencyPair(cancelOrderCommand.OrderId);
             OrderCancellation cancellation = new OrderCancellation(cancelOrderCommand.OrderId,
                                                                    cancelOrderCommand.TraderId, currencyPair);
             InputDisruptorPublisher.Publish(InputPayload.CreatePayload(cancellation));
             return(new CancelOrderResponse(true, "Cancel Request Accepted"));
         }
         return(new CancelOrderResponse(false, new InvalidDataException("Invalid orderid").ToString()));
     }
     catch (Exception exception)
     {
         return(new CancelOrderResponse(false, exception.Message));
     }
 }