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 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 Clear()
{
BuyOrders.Clear();
SellOrders.Clear();
Position = 0;
AvgPrice = 0;
}
public int GetTotalBuyVolume()
{
if (BuyOrders.Count <= 0)
{
return(0);
}
return(BuyOrders.Select(order => order.Volume).Sum());
}
private void CancelBuyOrder(BuyOrder order)
{
order.OrderAccount.DepositInto(BalanceAccount, order.OrderAccount.Balance);
lock (BuyOrders)
{
BuyOrders.Remove(order);
}
Updated?.Invoke(this, this);
}
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 BuyOrder[] GetWithPriceGreaterOrEqual(decimal?sellPrice)
{
var buyOrders = new BuyOrders {
BuyPrice = sellPrice
};
var ordersWithPriceGreaterOrEqual = buyOrders.GetWithPriceLessOrEqual();
var result = EntitiesToLogicUnit(ordersWithPriceGreaterOrEqual);
return(result);
}
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));
}
public void AddOrder(MarketOrder order)
{
if (order.IsBid)
{
BuyOrders.Add(order);
}
else
{
SellOrders.Add(order);
}
}
private void Add()
{
var newOrder = new BuyOrders
{
BuyComment = BuyComment,
BuyDate = DateTimeOffset.Now,
BuyPrice = BuyPrice,
NumbersToBuy = NumbersToBuy
};
newOrder.Insert();
}
public void Save()
{
var instance = new BuyOrders
{
BuyPrice = BuyPrice,
Id = Id,
NumbersToBuy = NumbersToBuy,
BuyComment = BuyComment,
BuyDate = BuyDate
};
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 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 BuyOrder(BuyOrders order)
{
if (order == null)
{
Reset();
}
else
{
Id = order.Id;
NumbersToBuy = order.NumbersToBuy;
BuyComment = order.BuyComment;
BuyDate = order.BuyDate;
BuyPrice = order.BuyPrice;
}
}
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 = 1;
m_BuyOrders = new BuyOrders(m_Instrument);
for (int i = 0, j = 10; i < 10; ++i, ++j)
{
Thread.Sleep(2);
m_BuyOrders.Insert(new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled,
Order.BuyOrSell.Buy, 5, (ulong)j));
}
for (int i = 0, j = 10; i < 10; ++i, ++j)
{
m_BuyOrders.Insert(new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled,
Order.BuyOrSell.Buy, 5, (ulong)j));
}
}
private void ExecuteBuyOrder(BuyOrder order)
{
Security security;
if (!Securities.TryGetValue(order.SecurityName, out security))
{
Securities.Add(order.SecurityName, order.Security);
}
else
{
Securities[order.SecurityName].Merge(order.Security);
}
lock (BuyOrders)
{
BuyOrders.Remove(order);
}
Updated?.Invoke(this, this);
}
public void Init()
{
m_Instrument = 1;
m_BuyOrders = new BuyOrders(m_Instrument);
for (int i = 0, j = 10; i < 10; ++i, ++j)
{
Thread.Sleep(2);
m_BuyOrders.Insert(new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled,
Order.BuyOrSell.Buy, 5, (ulong)j));
}
for (int i = 0, j = 10; i < 10; ++i, ++j)
{
m_BuyOrders.Insert(new EquityOrder(m_Instrument, Order.OrderTypes.GoodUntilCancelled,
Order.BuyOrSell.Buy, 5, (ulong)j));
}
}
public static BuyOrder[] LoadAll()
{
var buyOrders = BuyOrders.FindAll();
var buyOrdersList = new List <BuyOrder>();
if (buyOrders != null)
{
foreach (var order in buyOrders)
{
var buyOrder = new BuyOrder(order);
buyOrdersList.Add(buyOrder);
}
}
var result = buyOrdersList.ToArray();
return(result);
}
public BuyOrder CreateBuyOrder(string name, ulong quantity, ulong pricePerItem)
{
var orderAccount = new Account(0);
if (!BalanceAccount.DepositInto(orderAccount, quantity * pricePerItem))
{
return(null);
}
var order = new BuyOrder(name, pricePerItem, quantity, orderAccount);
order.AddCancelAction(CancelBuyOrder);
order.AddExecuteAction(ExecuteBuyOrder);
lock (BuyOrders)
{
BuyOrders.Add(order);
}
Updated?.Invoke(this, this);
return(order);
}
private async Task GetMarketDataOrders()
{
IsBusy = true;
try
{
var marketOrders = await RestRepository.GetMarketOrdersData(Coin.Symbol);
SourceList.Clear();
BuyOrders.Clear();
SourceList.AddRange(marketOrders.BuyOrders);
BuyOrders.AddRange(LoadBuyOrders(0));
} catch (Exception e)
{
Crashes.TrackError(e);
await PageDialogService.DisplayAlertAsync("Error", e.Message, "OK");
} finally
{
IsBusy = false;
}
}
public bool ContainsOrder(ILimitOrder order)
{
switch (order.Way)
{
case WayEnum.Buy:
if (BuyOrders.Contains(order))
{
return(true);
}
break;
case WayEnum.Sell:
if (SellOrders.Contains(order))
{
return(true);
}
break;
}
return(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 FindBuyOrderIndex(string orderId, int cookie)
{
int index = -1;
if (!orderId.Equals("")) // поиск только по orderId
{
index = BuyOrders.FindIndex(x => x.OrderId.Equals(orderId));
return(index);
}
else
{
index = BuyOrders.FindIndex(x => x.OrderId.Equals(orderId));
if (index == -1 || orderId.Equals(""))
{
index = -1;
}
if (index != -1)
{
return(index);
}
index = BuyOrders.FindIndex(x => x.Cookie == cookie);
}
return(index);
}
public TestDbState AddOrder(BuyOrder buyOrder)
{
BuyOrders.Add(buyOrder);
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 OrderProcessor(BuyOrders buyOrders, SellOrders sellOrders, Trades trades)
: this(buyOrders, sellOrders, trades,
TryMatchOrder,
TryMatchOrder)
{
}
public SynchronousOrderProcessor(BuyOrders buyOrders, SellOrders sellOrders, Trades trades)
: base(buyOrders, sellOrders, trades)
{
}
public OrderBook(int instrument, BuyOrders buyOrders, SellOrders sellOrders, Trades trades)
: this(
instrument, buyOrders, sellOrders, trades, new SynchronousOrderProcessor(buyOrders, sellOrders, trades))
{
}
public ThreadPooledOrderProcessor(BuyOrders buyOrders, SellOrders sellOrders, Trades trades)
: base(buyOrders, sellOrders, trades)
{
}
