public void UpdateBuyOrders(Ticker ticker)
{
List <CryptoOrder> removedOrders = new List <CryptoOrder>();
foreach (var buyOrder in _pendingBuyOrders)
{
if (ticker.Ask <= buyOrder.PricePerUnit)
{
//Console.WriteLine($"Closed buy order {buyOrder.Uuid}");
buyOrder.Closed = ticker.Timestamp;
buyOrder.IsClosed = true;
buyOrder.IsClosed = true;
OrderUpdated.OnNext(buyOrder);
removedOrders.Add(buyOrder);
}
if (buyOrder.Canceled)
{
removedOrders.Add(buyOrder);
}
}
foreach (var removedOrder in removedOrders)
{
_pendingBuyOrders.Remove(removedOrder);
}
}
partial void OnHandle(OrderUpdated @event)
{
Entities.OrderEntity entity = OrderRepository.Load(@event.Rsn);
entity = AutomapHelper.Automap(@event, entity);
OrderRepository.Update(entity);
}
private void OnOrderUpdated(List <LaborDetail.ListItem> orders)
{
if (OrderUpdated != null)
{
OrderUpdated.Invoke(this, new OrderEventArgs(orders));
}
}
private void UpdateOrder(Order order)
{
order.Status = OrderStatus.Updated;
Console.WriteLine($"order updated in book: {order}");
OrderUpdated?.Invoke(this, new OrderUpdateEventArgs(order));
}
public when_order_update_is_received()
{
var makeReservationCommand = sut.Commands.Select(e => e.Body).OfType <MakeSeatReservation>().Single();
reservationId = makeReservationCommand.ReservationId;
orderUpdated = new OrderUpdated {
SourceId = orderId,
Seats = new[] { new SeatQuantity(Guid.NewGuid(), 3) }
};
sut.Handle(orderUpdated);
}
public void Handle(OrderUpdated @event)
{
var dto = GetDraftOrder(@event.SourceId);
if (WasNotAlreadyHandled(dto, @event.Version))
{
var newItems = @event.Seats.Select(seat => new DraftOrderItem(seat.SeatType, seat.Quantity));
dto.Lines = newItems.ToList();
dto.State = DraftOrder.States.PendingReservation;
dto.OrderVersion = @event.Version;
draftOrderRepository.Update(dto);
}
}
public async Task <Unit> UpdateOrder(CryptoOrder cryptoOrder)
{
try
{
Log($"Closed order {cryptoOrder.Uuid} as {cryptoOrder.OrderType} at {cryptoOrder.Limit}");
switch (cryptoOrder.OrderType)
{
case CryptoOrderType.LimitSell:
TraderState.Budget.Available += cryptoOrder.Price;
var tradeForSellOrder = TraderState.Trades.FirstOrDefault(t => t.SellOrder.Uuid == cryptoOrder.Uuid);
if (tradeForSellOrder != null)
{
if (cryptoOrder.Canceled)
{
tradeForSellOrder.Status = TradeStatus.Bought;
tradeForSellOrder.SellOrder.IsOpened = false;
return(await Task.FromResult(Unit.Default));
}
var tradeProfit = tradeForSellOrder.BuyOrder.Price.GetReadablePercentageChange(tradeForSellOrder.SellOrder.Price);
TraderState.Budget.Profit += tradeProfit;
TraderState.Budget.Earned += tradeForSellOrder.SellOrder.Price - tradeForSellOrder.BuyOrder.Price;
Log($"{cryptoOrder.Uuid}: SELL - {tradeProfit}");
tradeForSellOrder.Profit = tradeProfit;
tradeForSellOrder.Status = TradeStatus.Completed;
tradeForSellOrder.SellOrder = cryptoOrder;
}
break;
case CryptoOrderType.LimitBuy:
var tradeForBuyOrder = TraderState.Trades.FirstOrDefault(t => t.BuyOrder.Uuid == cryptoOrder.Uuid);
if (tradeForBuyOrder != null)
{
if (cryptoOrder.Canceled)
{
TraderState.Trades.Remove(tradeForBuyOrder);
return(await Task.FromResult(Unit.Default));
}
tradeForBuyOrder.Status = TradeStatus.Bought;
tradeForBuyOrder.BuyOrder = cryptoOrder;
}
break;
}
}
finally
{
OrderUpdated.OnNext(cryptoOrder);
}
return(await Task.FromResult(Unit.Default));
}
public void Handle(OrderUpdated @event)
{
var pInfo = repository.GetBy(x => x.OrderId == @event.SourceId).FirstOrDefault();
if (pInfo != null)
{
var manager = new RegistrationProcessManager(pInfo);
manager.Handle(@event);
context.RegisterModified(manager.ProcessInfo);
context.Commit();
}
else
{
Trace.TraceError("Failed to locate the registration process manager handling the order with id {0}.", @event.SourceId);
}
}
public void Handle(OrderUpdated @event)
{
using (var context = contextFactory.Invoke()) {
var pm = context.Find(x => x.OrderId == @event.SourceId);
if (pm != null)
{
pm.Handle(@event);
context.Save(pm);
}
else
{
Trace.TraceError("Failed to locate the registration process manager handling the order with id {0}.", @event.SourceId);
}
}
}
public void Handle(OrderUpdated @event)
{
using (var context = this._contextFactory.Invoke()) {
var dto = context.Set <DraftOrder>().Include(o => o.Lines).First(o => o.OrderId == @event.SourceId);
if (WasNotAlreadyHandled(dto, @event.Version))
{
var linesSet = context.Set <DraftOrderItem>();
foreach (var line in dto.Lines.ToArray())
{
linesSet.Remove(line);
}
dto.Lines.AddRange(@event.Seats.Select(seat => new DraftOrderItem(seat.SeatType, seat.Quantity)));
dto.State = DraftOrder.States.PendingReservation;
dto.OrderVersion = @event.Version;
context.Save(dto);
}
}
}
public void Handle(OrderUpdated message)
{
if (this.State == ProcessState.AwaitingReservationConfirmation ||
this.State == ProcessState.ReservationConfirmationReceived)
{
this.State = ProcessState.AwaitingReservationConfirmation;
var seatReservationCommand = new MakeSeatReservation {
ConferenceId = this.ConferenceId,
ReservationId = this.ReservationId,
Seats = message.Seats.ToList()
};
this.SeatReservationCommandId = seatReservationCommand.Id;
this.AddCommand(seatReservationCommand);
}
else
{
throw new InvalidOperationException("The order cannot be updated at this stage.");
}
}
public void Setup()
{
this._sut = new RegistrationProcessManager();
this._orderId = Guid.NewGuid();
this._conferenceId = Guid.NewGuid();
this._sut.Handle(new OrderPlaced()
{
SourceId = this._orderId,
ConferenceId = this._conferenceId,
Seats = new[] { new SeatQuantity(Guid.NewGuid(), 2) },
ReservationAutoExpiration = DateTime.UtcNow.Add(TimeSpan.FromMinutes(22))
});
this._orderUpdated = new OrderUpdated()
{
SourceId = Guid.NewGuid(),
Seats = new[] { new SeatQuantity(Guid.NewGuid(), 3) }
};
_sut.Handle(this._orderUpdated);
}
public void Handle(OrderUpdated message)
{
if (this.State == ProcessState.AwaitingReservationConfirmation ||
this.State == ProcessState.ReservationConfirmationReceived)
{
this.State = ProcessState.AwaitingReservationConfirmation;
var anchorReservationCommand =
new MakeAnchorReservation
{
WorkshopID = this.WorkshopID,
ReservationId = this.ReservationID,
Anchors = message.Anchors.ToList()
};
this.AnchorReservationCommandID = anchorReservationCommand.Id;
this.AddCommand(anchorReservationCommand);
}
else
{
throw new InvalidOperationException("The order cannot be updated at this stage.");
}
}
public void Handle(OrderUpdated @event)
{
using (var context = factory.Create())
{
var dto = DbContext.Set <DraftOrder>().Include(o => o.Lines).First(o => o.OrderID == @event.SourceId);
if (WasNotAlreadyHandled(dto, @event.Version))
{
var linesSet = DbContext.Set <DraftOrderItem>();
foreach (var line in dto.Lines.ToArray())
{
linesSet.Remove(line);
}
dto.Lines.AddRange(@event.Anchors.Select(anchor => new DraftOrderItem(anchor.AnchorType, anchor.Quantity)));
dto.State = DraftOrder.States.PendingReservation;
dto.OrderVersion = @event.Version;
//DbContext.Save(dto);
context.SaveChanges();
}
}
}
public void UpdateSellOrders(Ticker ticker)
{
List <CryptoOrder> removedOrders = new List <CryptoOrder>();
foreach (var sellOrder in _pendingSellOrders.Where(s => s.IsClosed == false))
{
if (ticker.Bid >= sellOrder.PricePerUnit || sellOrder.OrderType == CryptoOrderType.ImmediateSell)
{
sellOrder.IsClosed = true;
sellOrder.IsClosed = true;
sellOrder.Closed = ticker.Timestamp;
sellOrder.OrderType = CryptoOrderType.LimitSell;
removedOrders.Add(sellOrder);
OrderUpdated.OnNext(sellOrder);
}
}
foreach (var removedOrder in removedOrders)
{
_pendingSellOrders.Remove(removedOrder);
}
}
public void When(OrderUpdated orderUpdated)
{
}
public async Task <Unit> UpdateOrder(CryptoOrder cryptoOrder)
{
try
{
if (cryptoOrder.IsClosed == false)
{
return(await Task.FromResult(Unit.Default));
}
switch (cryptoOrder.OrderType)
{
case CryptoOrderType.LimitSell:
TraderState.Budget.Available += cryptoOrder.Price;
var tradeForSellOrder = TraderState.Trades.FirstOrDefault(t => t.SellOrder.Uuid == cryptoOrder.Uuid);
if (tradeForSellOrder != null)
{
if (cryptoOrder.Canceled)
{
tradeForSellOrder.Status = TradeStatus.Bought;
tradeForSellOrder.SellOrder.IsClosed = true;
return(await Task.FromResult(Unit.Default));
}
tradeForSellOrder.SellOrder = cryptoOrder;
var tradeProfit = tradeForSellOrder.BuyOrder.Price.GetReadablePercentageChange(tradeForSellOrder.SellOrder.Price);
Console.WriteLine($"Sold {tradeForSellOrder.BuyOrder.Uuid} with profit {tradeProfit} \t\t" +
$" {tradeForSellOrder.BuyReason}: {tradeForSellOrder.BuyOrder.PricePerUnit} " +
$"\t\t {tradeForSellOrder.SellReason}: {tradeForSellOrder.SellOrder.PricePerUnit}");
TraderState.Budget.Profit += tradeProfit;
TraderState.Budget.Earned += tradeForSellOrder.SellOrder.Price - tradeForSellOrder.BuyOrder.Price;
tradeForSellOrder.Profit = tradeProfit;
tradeForSellOrder.Status = TradeStatus.Completed;
var tradeWithTriggeredBuy =
TraderState.Trades.FirstOrDefault(t =>
t.TriggeredBuy && t.Status != TradeStatus.Completed);
if (tradeWithTriggeredBuy != null &&
TraderState.Trades.Count(t => t.TriggeredBuy && t.Status != TradeStatus.Completed) == 0)
{
//Console.WriteLine($"Set triggered buy to false for {tradeWithTriggeredBuy.BuyOrder.Uuid}");
tradeWithTriggeredBuy.TriggeredBuy = false;
}
}
break;
case CryptoOrderType.LimitBuy:
var tradeForBuyOrder = TraderState.Trades.FirstOrDefault(t => t.BuyOrder.Uuid == cryptoOrder.Uuid);
if (tradeForBuyOrder != null)
{
if (cryptoOrder.Canceled)
{
TraderState.Trades.Remove(tradeForBuyOrder);
return(await Task.FromResult(Unit.Default));
}
tradeForBuyOrder.Status = TradeStatus.Bought;
tradeForBuyOrder.BuyOrder = cryptoOrder;
}
break;
}
}
finally
{
OrderUpdated.OnNext(cryptoOrder);
}
return(await Task.FromResult(Unit.Default));
}
private void OnOrderUpdated(OrderUpdated e)
{
this.seats = e.Seats.ToList();
}
private void OnOrderUpdated(OrderUpdated e)
{
this.anchors = e.Anchors.ToList();
}
protected void OnOrderUpdated(Order order)
{
OrderUpdated?.Invoke(this, new OrderBookEventArgs(order));
}
protected void OnOrderUpdate(BittrexStreamOrderData bittrexOrder)
{
OrderUpdated.OnNext(bittrexOrder.ToCryptoOrder());
}
