public void AssertState(ExchangeDbContext dbContext)
{
Assert.Equal(Deals.Count, dbContext.Deals.Count());
Assert.Equal(SellOrders.Count, dbContext.SellOrders.Count());
Assert.Equal(BuyOrders.Count, dbContext.BuyOrders.Count());
var hasAllDeals = Deals.All(expectedDeal => dbContext.Deals.Any(actual => actual.Price == expectedDeal.Price &&
actual.Qty == expectedDeal.Qty &&
actual.BuyerEmail == expectedDeal.BuyerEmail &&
actual.SellerEmail == expectedDeal.SellerEmail));
Assert.True(hasAllDeals, "Database should include all expected deals");
var hasAllSellOrders = SellOrders.All(expectedSellOrder => dbContext.SellOrders.Any(actual =>
expectedSellOrder.Email == actual.Email &&
expectedSellOrder.Price == actual.Price &&
expectedSellOrder.Qty == actual.Qty));
Assert.True(hasAllSellOrders, "Database should include all expected sell orders");
var hasAllBuyOrders = BuyOrders.All(expectedBuyOrder => dbContext.BuyOrders.Any(actual =>
expectedBuyOrder.Email == actual.Email &&
expectedBuyOrder.Price == actual.Price &&
expectedBuyOrder.Qty == actual.Qty));
Assert.True(hasAllBuyOrders, "Database should include all expected sell orders");
}
public void RemoveOrder(string orderId, int cookie)
{
/* int buyIndex = BuyOrders.FindIndex(order => (order.OrderId == orderId));
* int sellIndex = SellOrders.FindIndex(order => (order.OrderId == orderId));
* if (buyIndex >= 0)
* BuyOrders.RemoveAt(buyIndex);
* else if (sellIndex >= 0)
* SellOrders.RemoveAt(sellIndex);
* else
* {
* buyIndex = BuyOrders.FindIndex(order => (order.Cookie == cookie));
* sellIndex = SellOrders.FindIndex(order => (order.Cookie == cookie));
* if (buyIndex >= 0)
* BuyOrders.RemoveAt(buyIndex);
* else if (sellIndex >= 0)
* SellOrders.RemoveAt(sellIndex);
* } */
Order foundOrder = FindOrder(orderId, cookie);
if (foundOrder != null)
{
if (foundOrder.Action == ActionEnum.BUY)
{
BuyOrders.Remove(foundOrder);
}
else if (foundOrder.Action == ActionEnum.SELL)
{
SellOrders.Remove(foundOrder);
}
else
{
throw new SmartException(ExceptionImportanceLevel.LOW, "RemoveOrder", "StrategyState", "No other choices in foundOrder.Action");
}
}
}
public void Clear()
{
BuyOrders.Clear();
SellOrders.Clear();
Position = 0;
AvgPrice = 0;
}
public int GetTotalSellVolume()
{
if (SellOrders.Count <= 0)
{
return(0);
}
return(SellOrders.Select(order => order.Volume).Sum());
}
public static SellOrder[] LoadAll()
{
var sellOrders = SellOrders.FindAll();
var result = EntitiesToLogicUnit(sellOrders);
return(result);
}
public OrderProcessor(BuyOrders buyOrders, SellOrders sellOrders, Trades trades,
OrderMatcher tryMatchBuyOrder, OrderMatcher tryMatchSellOrder)
{
m_BuyOrders = buyOrders;
m_SellOrders = sellOrders;
m_Trades = trades;
TryMatchBuyOrder = tryMatchBuyOrder;
TryMatchSellOrder = tryMatchSellOrder;
}
public OrderProcessor(BuyOrders buyOrders, SellOrders sellOrders, Trades trades,
OrderMatcher tryMatchBuyOrder, OrderMatcher tryMatchSellOrder)
{
m_BuyOrders = buyOrders;
m_SellOrders = sellOrders;
m_Trades = trades;
TryMatchBuyOrder = tryMatchBuyOrder;
TryMatchSellOrder = tryMatchSellOrder;
}
public static SellOrder[] GetWithPriceLessOrEqual(decimal?buyPrice)
{
var sellOrders = new SellOrders {
SellPrice = buyPrice
};
var ordersWithPriceLessOrEqual = sellOrders.GetWithPriceLessOrEqual();
var result = EntitiesToLogicUnit(ordersWithPriceLessOrEqual);
return(result);
}
public void AddOrder(MarketOrder order)
{
if (order.IsBid)
{
BuyOrders.Add(order);
}
else
{
SellOrders.Add(order);
}
}
public Order GetMatchingOrder(UserHandler handler, TradeOffer trade)
{
Order buy = BuyOrders.FirstOrDefault((o) => o.TradeOfferMatches(handler, trade) == true);
if (buy != null)
{
return(buy);
}
return(SellOrders.FirstOrDefault((o) => o.TradeOfferMatches(handler, trade) == true));
}
private void Add()
{
var newOrder = new SellOrders
{
SellComment = SellComment,
SellDate = DateTimeOffset.Now,
SellPrice = SellPrice,
NumbersToSell = NumbersToSell
};
newOrder.Insert();
}
public MarketOrder LowestSellOrder(int?minimumQuantity)
{
MarketOrder item = null;
if (SellOrders != null)
{
var filter = minimumQuantity ?? UseableQuantity;
item = SellOrders.FirstOrDefault(arg => arg.Quantity > filter && arg.Security > SecurityLevel);
}
return(item);
}
public void Save()
{
var instance = new SellOrders
{
SellPrice = SellPrice,
Id = Id,
NumbersToSell = NumbersToSell,
SellComment = SellComment,
SellDate = SellDate
};
instance.Update();
}
public void Init()
{
m_Instrument = 1;
m_BuyOrder = new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled, Order.BuyOrSell.Buy, 100,
100ul);
m_SellOrder = new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled, Order.BuyOrSell.Sell, 90,
100ul);
m_SellOrders = new SellOrders(m_Instrument);
m_BuyOrders = new BuyOrders(m_Instrument);
m_SellOrders.Insert(m_SellOrder);
m_BuyOrders.Insert(m_BuyOrder);
m_Trades = new Trades(m_Instrument);
m_TradeProcessor = m_Trades.TradeProcessingStrategy as Trades.InMemoryTradeProcessor;
}
public void Init()
{
m_Instrument = new Instrument("GOOG");
m_BuyOrder = new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled, Order.BuyOrSell.Buy, 100M,
100ul);
m_SellOrder = new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled, Order.BuyOrSell.Sell, 90,
100ul);
m_SellOrders = new SellOrders(m_Instrument);
m_BuyOrders = new BuyOrders(m_Instrument);
m_SellOrders.Insert(m_SellOrder);
m_BuyOrders.Insert(m_BuyOrder);
m_Trades = new Trades(m_Instrument);
m_TradeProcessor = m_Trades.TradeProcessingStrategy as Trades.InMemoryTradeProcessor;
}
public SellOrder(SellOrders order)
{
if (order == null)
{
Reset();
}
else
{
Id = order.Id;
NumbersToSell = order.NumbersToSell;
SellComment = order.SellComment;
SellDate = order.SellDate;
SellPrice = order.SellPrice;
}
}
public void Init()
{
m_Instrument = new Instrument("MSFT");
m_BuyOrders = new BuyOrders(m_Instrument);
m_SellOrders = new SellOrders(m_Instrument);
m_Trades = new Trades(m_Instrument);
m_OrderBook = new OrderBook(m_Instrument, m_BuyOrders, m_SellOrders, m_Trades);
m_Orders = new List <Order>
{
new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled, Order.BuyOrSell.Buy, 100, 100),
new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilDate, Order.BuyOrSell.Sell, 110, 100)
};
}
public void Init()
{
m_Instrument = new Instrument("MSFT");
m_BuyOrders = new BuyOrders(m_Instrument);
m_SellOrders = new SellOrders(m_Instrument);
m_Trades = new Trades(m_Instrument);
m_OrderBook = new OrderBook(m_Instrument, m_BuyOrders, m_SellOrders, m_Trades);
m_Orders = new List<Order>
{
new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled, Order.BuyOrSell.Buy, 100, 100),
new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilDate, Order.BuyOrSell.Sell, 110, 100)
};
}
public void RemoveOrder(ILimitOrder order)
{
switch (order.Way)
{
case WayEnum.Buy:
BuyOrders.Remove(order);
break;
case WayEnum.Sell:
SellOrders.Remove(order);
break;
}
order.UnRegisterDeleteNotificationHandler(HandleDeleteOrFilled);
order.UnRegisterFilledNotification(HandleDeleteOrFilled);
}
private void AddOrder(Order newOrder)
{
if (newOrder.Action == ActionEnum.BUY)
{
BuyOrders.Add(newOrder);
}
else if (newOrder.Action == ActionEnum.SELL)
{
SellOrders.Add(newOrder);
}
else
{
throw new SmartException(ExceptionImportanceLevel.HIGH, "AddOrder", "StrategyState", "No other options. New Order = " + newOrder.ToString());
}
MakeConsistent();
}
public Trade[] Execute(Order order)
{
if (order.Quantity > 0)
{
BuyOrders.Enqueue(order);
}
else
{
SellOrders.Enqueue(order);
}
var trades = new List <Trade>();
while (BuyOrders.Count > 0 && SellOrders.Count > 0)
{
var buy = BuyOrders.Peek();
var sell = SellOrders.Peek();
if (buy.Price < sell.Price)
{
break;
}
var quantity = Math.Min((buy.RemainingQuantity), sell.RemainingQuantity);
var price = buy.Generation < sell.Generation ? buy.Price : sell.Price;
var trade = new Trade(buy.Participant, sell.Participant, buy.Instrument, quantity, price);
trades.Add(trade);
buy.Fill(quantity);
sell.Fill(quantity);
if (buy.RemainingQuantity == 0)
{
BuyOrders.Dequeue();
}
if (sell.RemainingQuantity == 0)
{
SellOrders.Dequeue();
}
}
return(trades.ToArray());
}
/// <summary>
/// Находит и обновляет заявку. Известно, что заявка существует
/// </summary>
/// <param name="ev"></param>
private void UpdateOrder(UpdateOrderEvent ev)
{
int index = FindBuyOrderIndex(ev.OrderId, ev.Cookie);
if (index != -1)
{
if (ev.Filled <= 0 || ev.Amount <= 0)
{
BuyOrders.RemoveAt(index);
}
else
{
BuyOrders[index].Cookie = ev.Cookie;
BuyOrders[index].FilledVolume = (int)ev.Filled;
BuyOrders[index].OrderId = ev.OrderId;
BuyOrders[index].Price = ev.Price;
BuyOrders[index].StopPrice = ev.Stop;
BuyOrders[index].Type = Server.OrderTypeCast(ev.Type);
BuyOrders[index].Volume = (int)ev.Amount;
BuyOrders[index].Action = Server.ActionCast(ev.Action);
}
}
else
{
index = FindSellOrderIndex(ev.OrderId, ev.Cookie);
if (index != -1)
{
if (ev.Filled <= 0 || ev.Amount <= 0)
{
SellOrders.RemoveAt(index);
}
else
{
SellOrders[index].Cookie = ev.Cookie;
SellOrders[index].FilledVolume = (int)ev.Filled;
SellOrders[index].OrderId = ev.OrderId;
SellOrders[index].Price = ev.Price;
SellOrders[index].StopPrice = ev.Stop;
SellOrders[index].Type = Server.OrderTypeCast(ev.Type);
SellOrders[index].Volume = (int)ev.Amount;
SellOrders[index].Action = Server.ActionCast(ev.Action);
}
}
}
}
public OrderBook(int instrument, BuyOrders buyOrders, SellOrders sellOrders, Trades trades,
OrderProcessor orderProcessingStrategy)
{
if (instrument == null) throw new ArgumentNullException("instrument");
if (buyOrders == null) throw new ArgumentNullException("buyOrders");
if (sellOrders == null) throw new ArgumentNullException("sellOrders");
if (trades == null) throw new ArgumentNullException("trades");
if (orderProcessingStrategy == null) throw new ArgumentNullException("orderProcessingStrategy");
if (!(instrument == buyOrders.Instrument && instrument == sellOrders.Instrument))
throw new ArgumentException("instrument does not match buyOrders and sellOrders instrument");
Instrument = instrument;
BuyOrders = buyOrders;
SellOrders = sellOrders;
Trades = trades;
OrderProcessingStrategy = orderProcessingStrategy;
Statistics = new Statistics();
}
public void Init()
{
m_Instrument = new Instrument("MSFT");
m_SellOrders = new SellOrders(m_Instrument);
for (int i = 0, j = 10; i < 10; ++i, ++j)
{
Thread.Sleep(2);
m_SellOrders.Insert(new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled,
Order.BuyOrSell.Sell, 5, (ulong)j));
}
for (int i = 0, j = 10; i < 10; ++i, ++j)
{
m_SellOrders.Insert(new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled,
Order.BuyOrSell.Sell, 5, (ulong)j));
}
}
public void Init()
{
m_Instrument = 1;
m_SellOrders = new SellOrders(m_Instrument);
for (int i = 0, j = 10; i < 10; ++i, ++j)
{
Thread.Sleep(2);
m_SellOrders.Insert(new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled,
Order.BuyOrSell.Sell, 5, (ulong)j));
}
for (int i = 0, j = 10; i < 10; ++i, ++j)
{
m_SellOrders.Insert(new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled,
Order.BuyOrSell.Sell, 5, (ulong)j));
}
}
private async Task GetMarketDataOrders()
{
try
{
IsBusy = true;
var marketOrders = await RestRepository.GetMarketOrdersData(Coin.Symbol);
SourceList.Clear();
SellOrders.Clear();
SourceList.AddRange(marketOrders.SellOrders);
SellOrders.AddRange(LoadSellOrders(0));
} catch (Exception e)
{
Crashes.TrackError(e);
await PageDialogService.DisplayAlertAsync("Error", e.Message, "OK");
} finally
{
IsBusy = false;
}
}
public void AddOrder(ILimitOrder order)
{
if (order.Price != Price)
{
return;
}
switch (order.Way)
{
case WayEnum.Buy:
BuyOrders.Add(order);
break;
case WayEnum.Sell:
SellOrders.Add(order);
break;
}
order.RegisterDeleteNotificationHandler(HandleDeleteOrFilled);
order.RegisterFilledNotification(HandleDeleteOrFilled);
}
private void initialize()
{
if (BuyOrders.Any())
{
CurrentBuyPrice = BuyOrders.MaxBy(order => order.Price).Price;
}
if (SellOrders.Any())
{
CurrentSellPrice = SellOrders.MinBy(order => order.Price).Price;
}
var high = new List <decimal>();
var low = new List <decimal>();
if (!MarketHistory.Any())
{
return;
}
foreach (MarketHistoryAggregateEntry entry in MarketHistory)
{
high.Add(entry.HighPrice);
low.Add(entry.LowPrice);
if (high.Count > DonchianLength)
{
high.RemoveAt(0);
}
if (low.Count > DonchianLength)
{
low.RemoveAt(0);
}
if (high.Any())
{
entry.DonchianHigh = high.Max();
}
if (low.Any())
{
entry.DonchianLow = low.Min();
}
entry.DonchianCenter = (entry.DonchianHigh + entry.DonchianLow) / 2;
}
}
private int FindSellOrderIndex(string orderId, int cookie)
{
int index = -1;
if (!orderId.Equals("")) // поиск только по orderId
{
index = SellOrders.FindIndex(x => x.OrderId.Equals(orderId));
return(index);
}
else
{
index = SellOrders.FindIndex(x => x.OrderId.Equals(orderId));
if (index == -1 || orderId.Equals(""))
{
index = -1;
}
if (index != -1)
{
return(index);
}
index = SellOrders.FindIndex(x => x.Cookie == cookie);
}
return(index);
}
public TestDbState AddOrder(SellOrder sellOrder)
{
SellOrders.Add(sellOrder);
return(this);
}
public OrderProcessor(BuyOrders buyOrders, SellOrders sellOrders, Trades trades)
: this(buyOrders, sellOrders, trades,
TryMatchOrder,
TryMatchOrder)
{
}
public DedicatedThreadsOrderProcessor(BuyOrders buyOrders, SellOrders sellOrders, Trades trades)
: base(buyOrders, sellOrders, trades)
{
m_Thread = new Thread(ProcessOrders);
m_Thread.Start();
}
public List <Order> CloneSellOrders()
{
return(SellOrders.Select(order => order.Clone()).ToList());
}
public OrderProcessor(BuyOrders buyOrders, SellOrders sellOrders, Trades trades)
: this(buyOrders, sellOrders, trades,
TryMatchOrder,
TryMatchOrder)
{
}
public DedicatedThreadsOrderProcessor(BuyOrders buyOrders, SellOrders sellOrders, Trades trades)
: base(buyOrders, sellOrders, trades)
{
m_Thread = new Thread(ProcessOrders);
m_Thread.Start();
}
public OrderBook(int instrument, BuyOrders buyOrders, SellOrders sellOrders, Trades trades)
: this(
instrument, buyOrders, sellOrders, trades, new SynchronousOrderProcessor(buyOrders, sellOrders, trades))
{
}
public SynchronousOrderProcessor(BuyOrders buyOrders, SellOrders sellOrders, Trades trades)
: base(buyOrders, sellOrders, trades)
{
}
public ThreadPooledOrderProcessor(BuyOrders buyOrders, SellOrders sellOrders, Trades trades)
: base(buyOrders, sellOrders, trades)
{
}
