public async Task <Unit> UpdateOrder(CryptoOrder cryptoOrder)
{
try
{
Console.WriteLine($"Closed order {cryptoOrder.Uuid} as {cryptoOrder.OrderType} at {cryptoOrder.Limit}");
switch (cryptoOrder.OrderType)
{
case CryptoOrderType.LimitSell:
Budget.Available += cryptoOrder.Price;
var tradeForSellOrder = 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);
Budget.Profit += tradeProfit;
Budget.Earned += tradeForSellOrder.SellOrder.Price - tradeForSellOrder.BuyOrder.Price;
Console.WriteLine($"{cryptoOrder.Uuid}: SELL - {tradeProfit}");
await _pushManager.TriggerPush(PushMessage.FromMessage($"Sold {Market} for profit {tradeProfit}%"));
tradeForSellOrder.Profit = tradeProfit;
tradeForSellOrder.Status = TradeStatus.Completed;
tradeForSellOrder.SellOrder = cryptoOrder;
}
break;
case CryptoOrderType.LimitBuy:
var tradeForBuyOrder = Trades.FirstOrDefault(t => t.BuyOrder.Uuid == cryptoOrder.Uuid);
if (tradeForBuyOrder != null)
{
await _pushManager.TriggerPush(PushMessage.FromMessage($"Bought {Market} at {cryptoOrder.Limit} BTC"));
if (cryptoOrder.Canceled)
{
tradeForBuyOrder.Status = TradeStatus.Empty;
tradeForBuyOrder.BuyOrder = new CryptoOrder();
return(await Task.FromResult(Unit.Default));
}
tradeForBuyOrder.Status = TradeStatus.Bought;
tradeForBuyOrder.BuyOrder = cryptoOrder;
}
break;
}
}
finally
{
if (!IsInTestMode)
{
var traderData = await _traderGrain.GetTraderData();
traderData.CurrentTicker = Ticker;
await _hubNotifier.UpdateTrader(traderData);
}
}
return(await Task.FromResult(Unit.Default));
}
protected StrategyTransaction CreateExitTransaction(Transaction t, string instrument, string side, string time, string type, double price, string id, string tradeId)
{
ITrade openTrade = Trades.FirstOrDefault(ot => ot.id == t.tradeId);
if (openTrade != null)
{
((MarketMinerTrade)openTrade).Closed = true;
}
return(CreateStrategyTransaction(instrument, side, time, type, price, null, null, id, null, tradeId));
}
private void DrawEntryAndExit(Point canvasPoint, int slotNumber)
{
if (!(0 <= canvasPoint.Y && canvasPoint.Y <= AvailableHeight))
{
return;
}
var barsPlot = Plots.FirstOrDefault(p => p.Type == PlotType.Candlestick);
if (barsPlot == null)
{
return;
}
var pb = PlotBoundaries[barsPlot];
var i = SlotOffset + slotNumber - pb.Left;
if (i < 0)
{
return;
}
var bar = ((DataSeries <Bar>)barsPlot.DataSeries)[i];
var trade = Trades.FirstOrDefault(t => t.EntryTime.Date == bar.Timestamp);
if (trade == null)
{
return;
}
//var p1 = PointToCanvas(0, trade.Entry, ViewRegion);
//var xBase = slotNumber * ParentChart.SlotPxWidth;
var p1 = PointToCanvas(slotNumber, trade.Entry, ViewRegion);
var xBase = p1.X - ParentChart.SlotPxWidth / 2;
var entryColor = trade.PositionDirection == PositionDirection.Long ? CandleGreen : CandleRed;
EntryArrow = AddPolygon(Brushes.Black, 1, entryColor,
new Point(xBase, p1.Y),
new Point(xBase - 8, p1.Y - 8),
new Point(xBase - 8, p1.Y + 8));
var p2 = PointToCanvas(0, trade.Exit, ViewRegion);
xBase += ParentChart.SlotPxWidth;
var exitColor = trade.PositionDirection == PositionDirection.Short ? CandleGreen : CandleRed;
ExitArrow = AddPolygon(Brushes.Black, 1, exitColor,
new Point(xBase, p2.Y),
new Point(xBase + 8, p2.Y - 8),
new Point(xBase + 8, p2.Y + 8));
}
/// <summary>
/// Clears the state items associated with an inactive thrust.
/// </summary>
/// <param name="chart">The chart containing the thrust pattern to be purged.</param>
/// <param name="thrust">The inactive thrust pattern to be purged.</param>
/// <returns></returns>
protected virtual async Task PurgeThrust(Chart chart, Thrust thrust)
{
// kill and save the signal
MCE.Signal signal = await SubscriptionCaller.Instance().GetSignalAsync(thrust.SignalID);
signal.Active = false;
await SubscriptionCaller.Instance().UpdateSignalAsync(signal);
// clear the chart
chart.Patterns.RemoveAll(p => p.Type == MACC.Constants.SignalType.Thrust);
Orders.Remove(Orders.FirstOrDefault(o => ((MarketMinerOrder)o).SignalID == signal.SignalID));
Trades.Remove(Trades.FirstOrDefault(t => ((MarketMinerTrade)t).SignalID == signal.SignalID));
}
public ITrade GetTradeById(string tradeId)
{
return(Trades.FirstOrDefault(tr => tr.Id == tradeId));
}
public MainViewModel()
{
Events = new ObservableCollection <string>();
_authService = ApiServiceBuilder <IUserService>
.Build(TradeServiceReferential.ServiceHost)
.Create();
_userToken = _authService.Login(new Credentials()
{
Username = "******",
Password = "******"
}).Result;
AppCore.Instance.ObjectProvider.Configure(config => config.For <TradeServiceToken>().Use(_userToken));
_tradeService = ApiServiceBuilder <ITradeService> .Build(TradeServiceReferential.ServiceHost)
.AddAuthorizationHeader(() => _userToken.Digest)
.Create();
_priceEventService = SignalRServiceBuilder <Price, PriceRequest>
.Create()
.Build(new PriceRequest((p) => true), (opts) =>
{
opts.AccessTokenProvider = () => Task.FromResult(_userToken.Digest);
});
_priceEventService
.Connect(Scheduler.Default, 1000)
.Subscribe((priceEvent) =>
{
foreach (var trade in Trades.Where(trade => trade.Asset == priceEvent.Asset).ToList())
{
Application.Current.Dispatcher.Invoke(() => trade.CurrentPrice = priceEvent.Value);
}
var ev = MakeEvent("PRICE", "PRICE", priceEvent.Asset, priceEvent.Value);
this.Notify(ev);
});
_tradeEventService = SignalRServiceBuilder <TradeEvent, TradeEventRequest>
.Create()
.Build(new TradeEventRequest((p) => true), (opts) =>
{
opts.AccessTokenProvider = () => Task.FromResult(_userToken.Digest);
});
_tradeEventService
.Connect(Scheduler.Default, 500)
.Subscribe((tradeEvent) =>
{
Application.Current.Dispatcher.Invoke(() =>
{
var trade = Trades.FirstOrDefault(t => t.Id == tradeEvent.TradeId);
if (null == trade)
{
return;
}
trade.Status = tradeEvent.Status;
});
this.Notify(MakeEvent("TRADE", _tradeEventService.Current.Endpoint, tradeEvent.TradeId, tradeEvent.Status));
});
Trades = new ObservableCollection <TradeViewModel>();
MakeTrade = new Command(async() =>
{
var asset = TradeServiceReferential.Assets.Random();
var counterparty = TradeServiceReferential.Counterparties.Random();
var rand = new Random();
var request = new TradeCreationRequest()
{
Counterparty = counterparty,
Asset = asset.Name,
Price = asset.Price,
Volume = rand.Next(1, 50),
Way = TradeWay.Buy
};
var tradeEvent = await _tradeService.CreateTrade(request);
var trade = await _tradeService.GetTradeById(tradeEvent.TradeId);
Application.Current.Dispatcher.Invoke(() => Trades.Add(new TradeViewModel(trade)));
});
Application.Current.Dispatcher.Invoke(async() =>
{
var trades = await _tradeService.GetAllTrades();
foreach (var trade in trades)
{
var vm = new TradeViewModel(trade);
Trades.Add(vm);
}
});
}
