public override Task<object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content, IFormatterLogger logger)
{
var trades = new Trades();
var symbol = _symbol;
using (var reader = new StreamReader(stream))
{
var line = reader.ReadLine();
var seperator = ",".ToCharArray();
while (null != (line = reader.ReadLine()))
{
if (!line.Contains("502 Bad Gateway"))
{
var parts = line.Split(seperator);
var unixtime = parts[0].Parse();
var price = decimal.Parse(parts[1], CultureInfo.InvariantCulture);
var quantity = decimal.Parse(parts[2], CultureInfo.InvariantCulture);
var datetime = Epoch.AddSeconds(unixtime);
trades.Add(symbol, datetime, price, quantity);
}
else throw new Exception("Bad Gateway");
}
}
var tcs = new TaskCompletionSource<object>();
tcs.SetResult(trades);
return tcs.Task;
}
private async Task UpdateTrades()
{
List <Trade> newTrades = new List <Trade>();
if (Trades.Count == 0)
{
Trades.Add(new Trade {
Status = TradeStatus.Empty
});
}
foreach (var trade in Trades.Where(t => t.Status != TradeStatus.Completed))
{
var newTrade = await UpdateTrade(trade);
if (newTrade != Trade.Empty)
{
newTrades.Add(newTrade);
}
}
if (newTrades.Count > 0)
{
Trades.AddRange(newTrades);
}
var canceledTrades = Trades.Where(t => t.Status == TradeStatus.Canceled).ToList();
foreach (var canceledTrade in canceledTrades)
{
Trades.Remove(canceledTrade);
}
}
public Trades CreateTrades()
{
var list = new Trades();
var rnd = new Random();
for (int i = 0; i < 50; i++)
{
var trade = new Trade()
{
Buys = rnd.Next(10000, 50000),
CIF = "A12345-" + i.ToString(CultureInfo.InvariantCulture),
DaysLeft = rnd.Next(1, 15),
Id = "T-987-" + i.ToString(CultureInfo.InvariantCulture),
IsAdvised = Convert.ToBoolean(i % 2),
Sells = rnd.Next(10000, 50000),
Spot = (decimal)0.25,
SpotDate = DateTime.Now.AddDays(rnd.Next(1, 15)),
TradeDate = DateTime.Now
};
list.Add(trade);
}
return list;
}
public override Task <object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content, IFormatterLogger logger)
{
var trades = new Trades();
var symbol = _symbol;
using (var reader = new StreamReader(stream)) {
var line = reader.ReadLine();
var seperator = ",".ToCharArray();
while (null != (line = reader.ReadLine()))
{
var parts = line.Split(seperator);
var unixtime = parts[0].Parse();
var price = parts[1].Parse();
var quantity = parts[2].Parse();
var datetime = Epoch.AddSeconds(unixtime);
trades.Add(symbol, datetime, price, quantity);
}
}
var tcs = new TaskCompletionSource <object>();
tcs.SetResult(trades);
return(tcs.Task);
}
public void AddTrades(IEnumerable <TradeRecord> trades)
{
foreach (var t in trades)
{
Trades.Add(t);
}
RedrawNeeded();
}
public async Task Execute(IReadOnlyList <Candle> candles)
{
var buy = BuySignal.BuildExpression();
var sell = SellSignal.BuildExpression();
// TODO: Add live and backtest modes, backtests run the full collection, live only calculates the last candle
for (int i = 24; i < candles.Count; i++)
{
try
{
var candle = candles[i];
if (buy.Invoke(candles, i) &&
await _shouldBuy.Invoke(Trades, candle))
{
//How to get buy amount from user?
var v = Trades.Any() && Trades.Last().Direction == TradeDirection.Sell ? Trades.Last().VolumeEur : InitialInvestment;
Trades.Add(new Trade()
{
TradeDate = candle.CloseDate,
Direction = TradeDirection.Buy,
Price = candle.Close,
Volume = Trades.Any() ? Trades.Last().VolumeEur / candle.Close : InitialInvestment / candle.Close,
VolumeEur = Trades.Any() ? Trades.Last().VolumeEur : InitialInvestment
});
}
//TODO: Add sell signal object with perc
//TODO: support 2 types of api, one with delegate and other with expression
if (sell.Invoke(candles, i) &&
await _shouldSell.Invoke(Trades, candle))
{
//How to get sell amount from user?
var v = Trades.Any() && Trades.Last().Direction == TradeDirection.Buy ? Trades.Last().Volume : InitialInvestment;
Trades.Add(new Trade()
{
TradeDate = candle.CloseDate,
Direction = TradeDirection.Sell,
Price = candle.Close,
Volume = v,
VolumeEur = v * candle.Close,
});
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ex.StackTrace);
throw;
}
}
if (Trades.Any())
{
ProfitEur = Trades.Last().Direction == TradeDirection.Sell ? Trades.Last().VolumeEur : Trades.Last().Volume *candles[candles.Count - 1].Close;
ProfitCoin = Trades.Last().Direction == TradeDirection.Buy ? Trades.Last().Volume : Trades.Last().VolumeEur / candles[candles.Count - 1].Close;
}
}
internal void OnTradeCall(Trade trade)
{
OnTrade?.Invoke(trade);
if (Trades == null)
{
Trades = new List <Trade>();
}
Trades.Add(trade);
}
protected void BuyOne(Price price)
{
Trade trade = new Trade();
trade.BuyOn = price.Date;
trade.BuyValue = price.LowValue;
Trades.Add(trade);
}
internal static Trades Add(this Trades source, string symbol, DateTimeOffset datetime, double price, double quantity)
{
source.Add(new Trade {
Symbol = symbol,
Datetime = datetime,
Price = price,
Quantity = quantity
});
return(source);
}
protected void BuyOne(Price price)
{
Trade trade = new Trade();
trade.BuyOn = price.Date;
trade.BuyValue = price.Value;
trade.BuyAmount = trade.DailyInvest / price.Value;
Trades.Add(trade);
}
internal void OnTradeCall(Trade trade)
{
if (OnTrade != null)
{
OnTrade(trade);
}
if (Trades == null)
{
Trades = new List <Trade>();
}
Trades.Add(trade);
}
public void Add(Trade trade)
{
if (GetCash(trade.Date) - trade.TotalValue < 0)
{
throw new InvalidOperationException("Not enough cash");
}
// adjust cash
Add(trade.Date, -trade.TotalValue);
Trades.Add(trade.Date, trade);
}
public Trade AddTrade(Stock stock, int quantity, TransactionType transactionType, decimal tradePrice)
{
var trade = new Trade
{
Stock = stock,
Quantity = quantity,
TransactionType = transactionType,
TradePrice = tradePrice,
LocalTimestamp = DateTimeProvider.Now
};
Trades.Add(trade);
return(trade);
}
/// <summary>
/// Creates a Sell trade in the Trades list using the supplied stockSymbol
/// An exception will be thrown if a stock with the supplied stockSymbol does not exist in the Stocks StockCollection
/// </summary>
/// <param name="stockSymbol"></param>
/// <param name="tradeDate"></param>
/// <param name="quantity"></param>
/// <param name="price"></param>
public void Sell(string stockSymbol, DateTime tradeDate, decimal quantity, decimal price)
{
try
{
if (!Stocks.StockExists(stockSymbol))
{
throw new Exception(StockDoesNotExistInStockList);
}
var trade = new Trade(stockSymbol, tradeDate, quantity, TradeType.Sell, price);
Trades.Add(trade);
}
catch (Exception ex)
{
throw new Exception("Exception in TradeLedger.Sell", ex);
}
}
public void CloseTrade(int offerId, int responseId, bool keepSelling)
{
TradeOffer offer = TradeOffers.SingleOrDefault(o => o.Id == offerId);
if (offer == null)
{
throw new ArgumentException("Cannot close a trade offer that does not exist");
}
var closingAnswer = offer.CloseTrade(responseId, keepSelling);
TradeOffers.Remove(offer);
//add new tradeoffer to the list when the vereniging wants to keep selling
if (keepSelling)
{
TradeOffers.Add(closingAnswer.Item2);
}
Trades.Add(closingAnswer.Item1);
}
public GridModel()
{
Trades.Add(new Trade {
Moniker = "IBMBMB", Price = 2323.23
});
Trades.Add(new Trade {
Moniker = "srt", Price = 787
});
Trades.Add(new Trade {
Moniker = "IBMertBMB", Price = 234
});
Trades.Add(new Trade {
Moniker = "sdg", Price = 23.23
});
Task.Factory.StartNew(TradeUpdater);
}
public async Task StartAsync()
{
_traderGrain = _orleansClient.GetGrain <ITraderGrain>(Market);
await _traderGrain.UpdateTrades(new List <Trade>());
await _traderGrain.SetMarketAsync(Market);
var traderState = await _traderGrain.GetTraderData();
Trades = traderState.Trades ?? new List <Trade>();
Strategy.Settings = TraderSettings.Default;
if (Trades.Count == 0)
{
Trades.Add(new Trade {
Status = TradeStatus.Empty
});
}
}
/// <summary>
/// Close the specified trade.
/// </summary>
/// <returns>The close.</returns>
/// <param name="trade">Trade.</param>
public bool Close(ITrade trade, decimal closePrice)
{
trade.CloseDate = Candle.Timestamp;
trade.ClosePrice = closePrice;
trade.FeesPaid += (FeesPercentage / 100m) * trade.Investment;
trade.ProfitDollars = (trade.Coins * trade.ClosePrice) - trade.Investment;
if (trade.TradeType == TradeType.Short)
{
trade.ProfitDollars = -trade.ProfitDollars;
}
trade.ProfitDollars -= trade.FeesPaid;
trade.ProfitPercentage = (trade.ProfitDollars / trade.Investment) * 100m;
Trades.Add(trade);
AccountBalance += trade.ProfitDollars;
return(true);
}
public Task SaveTradeAsync(Trade trade)
{
var items = Trades.Where(x => x.Id == trade.Id).ToList();
if (items.Count > 0)
{
foreach (var item in items)
{
Trades.Remove(item);
}
Trades.Add(trade);
}
else
{
Trades.Add(trade);
}
return(Task.FromResult(true));
}
public void AddInboxTrade(TradingModel message)
{
bool existing = false;
for (int i = 0; i < Trades.Count; i++)
{
if (Trades[i].Id == message.Id)
{
Trades[i].Accept = message.Accept;
existing = true;
}
}
if (!existing)
{
Trades.Add(message);
}
Trades = Trades.OrderByDescending(o => o.Time).ToList();
ShowNotificationIcon("test", null);
ShowMessages();
}
private void BitMex_TradesReceived(object sender, CollectionReceivedEventArgs <BitMexTrade> e)
{
var i = Instruments.FirstOrDefault(m => m.Id == e.Data[0].InstrumentId);
if (i != null)
{
i.LastError = null;
lock (Trades)
{
foreach (var m in e.Data)
{
Trades.Add(new TradeEntry(e.Action, i, m));
}
const int MAX = 100;
while (Trades.Count > 100)
{
Trades.RemoveAt(Trades.Count - 1 - MAX);
}
}
}
}
private void BtnAdd_Click(object sender, EventArgs e)
{
if (cbValue.Value == 0)
{
MessageBox.Show("Informe o valor");
return;
}
if (string.IsNullOrEmpty(Text))
{
MessageBox.Show("Informe o valor");
return;
}
if (Trades is null)
{
NewTrades();
}
Trades.Add(new Trade
{
Value = (double)cbValue.Value,
ClientSector = cmbClientSector.Text
});
BindGrid();
}
/// <summary>
/// Records an order and the corresponding trade (if closed). </summary>
/// <param name="order"> the order to be recorded </param>
/// <param name="isEntry"> true if the order is an entry, false otherwise (exit) </param>
private void RecordOrder(Order order, bool isEntry)
{
if (order == null)
{
throw new ArgumentException("Order should not be null");
}
// Storing the new order in entries/exits lists
if (isEntry)
{
_entryOrders.Add(order);
}
else
{
_exitOrders.Add(order);
}
// Storing the new order in orders list
_orders.Add(order);
if (OrderType.Buy.Equals(order.OrderType))
{
// Storing the new order in buy orders list
_buyOrders.Add(order);
}
else if (OrderType.Sell.Equals(order.OrderType))
{
// Storing the new order in sell orders list
_sellOrders.Add(order);
}
// Storing the trade if closed
if (CurrentTrade.Closed)
{
Trades.Add(CurrentTrade);
CurrentTrade = new Trade(_startingType);
}
}
public override Task <object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content, IFormatterLogger logger)
{
var trades = new Trades();
var symbol = _symbol;
using (var reader = new StreamReader(stream))
{
var line = reader.ReadLine();
var seperator = ",".ToCharArray();
while (null != (line = reader.ReadLine()))
{
if (!line.Contains("502 Bad Gateway"))
{
var parts = line.Split(seperator);
var unixtime = parts[0].Parse();
var price = decimal.Parse(parts[1], CultureInfo.InvariantCulture);
var quantity = decimal.Parse(parts[2], CultureInfo.InvariantCulture);
var datetime = Epoch.AddSeconds(unixtime);
trades.Add(symbol, datetime, price, quantity);
}
else
{
throw new Exception("Bad Gateway");
}
}
}
var tcs = new TaskCompletionSource <object>();
tcs.SetResult(trades);
return(tcs.Task);
}
public Trades EvalTrades(TradeSystem tradeSystem, TradeCondition buyCondition, TradeCondition sellCondition, double stopOutValue, bool log = false)
{
object[] logRowData = null;
if (log)
{
int logIndex = -1;
this.LogTables = new DataTable("LogTable");
this.LogTables.Columns.Add("Date");
this.LogTables.Columns.Add("Time");
this.LogTables.Columns.Add("Open");
this.LogTables.Columns.Add("High");
this.LogTables.Columns.Add("Low");
this.LogTables.Columns.Add("Close");
this.LogTables.Columns.Add("Volume");
this.LogTables.Columns.Add("StopOut");
this.LogTables.Columns.Add("Buy Signal");
this.LogTables.Columns.Add("Sell Signal");
TradeRule tr;
for (int i = 0; i < buyCondition.TradeRules.Count; i++)
{
tr = buyCondition.TradeRules[i];
logIndex++;
this.LogTables.Columns.Add(string.Format("{0} {1} {2} -BR{3}", tr.IndicatorName1, tr.CompareType.ToString(), tr.IndicatorName2, logIndex));
this.LogTables.Columns.Add(string.Format("Result -BR{0}", logIndex));
this.LogTables.Columns.Add(string.Format("JoinType -BR{0}", logIndex));
}
logIndex = 0;
for (int i = 0; i < sellCondition.TradeRules.Count; i++)
{
tr = sellCondition.TradeRules[i];
logIndex++;
this.LogTables.Columns.Add(string.Format("{0} {1} {2} -SR{3}", tr.IndicatorName1, tr.CompareType.ToString(), tr.IndicatorName2, logIndex));
this.LogTables.Columns.Add(string.Format("Result -SR{0}", logIndex));
this.LogTables.Columns.Add(string.Format("JoinType -SR{0}", logIndex));
}
logRowData = GetEmptyArray(this.LogTables.Columns.Count);
}
bool stopout = stopOutValue != double.MaxValue;
DateTime startDate = tradeSystem.StartDate;
DateTime endDate = tradeSystem.EndDate;
TradeType? tradeType = null;
if(tradeSystem.Longs && ! tradeSystem.Shorts)
{
tradeType = TradeType.longTrade;
}
else if (!tradeSystem.Longs && tradeSystem.Shorts)
{
tradeType = TradeType.shortTrade;
}
this.Winners = 0;
this.Losers = 0;
this.StopOuts = 0;
this.Trades = new Trades();
this.Capital = tradeSystem.FinancialSettings.InitialCapital;
bool[] buys = GetValues(buyCondition);
bool[] sells = GetValues(sellCondition);
List<int> endOfDaysIndexes = this.IndicatorLibraryAdapter.EndOfDayIndex;
bool buySignal;
bool sellSignal;
bool longEntered = false;
bool shortEntered = false;
double maxDrawDown = tradeSystem.FinancialSettings.MaxDrawdown;
double dollarsPerPoint = tradeSystem.FinancialSettings.DollarsPerPoint;
double roundTripCommision = tradeSystem.FinancialSettings.RoundTripCommission;
double currentCapital = tradeSystem.FinancialSettings.InitialCapital;
double equityPerContract = tradeSystem.FinancialSettings.EquityPerContract;
int maxContracts = tradeSystem.FinancialSettings.MaxContracts;
int counter = 0;
Trade trade = null;
StockPoint stockPoint = null;
DateTime currentDateTime;
#region Enter/Exit and Log Trade Func
int stopOutCounter = 0;
Action EnterLog = () =>
{
StockPoint point = StockPoints[counter];
logRowData[0] = point.Date;
logRowData[1] = point.Time;
logRowData[2] = point.Open.ToString("0.00");
logRowData[3] = point.High.ToString("0.00");
logRowData[4] = point.Low.ToString("0.00");
logRowData[5] = point.Close.ToString("0.00");
logRowData[6] = point.Volume.ToString();
if (stopOutCounter != this.StopOuts)
{
stopOutCounter = this.StopOuts;
this.LogTables.Rows[this.LogTables.Rows.Count - 1][7] = "1";
}
logRowData[7] = "0";
if (endOfDaysIndexes.Contains(counter))
{
logRowData[8] = "end of day";
logRowData[9] = "end of day";
}
else
{
logRowData[8] = buys[counter] ? "1" : "0";
logRowData[9] = sells[counter] ? "1" : "0";
}
int logIndex = 9;
TradeRule tr;
double[] evalData;
for (int i = 0; i < buyCondition.TradeRules.Count; i++)
{
tr = buyCondition.TradeRules[i];
evalData = this.Data[tr.Name];
logRowData[++logIndex] = string.Format("{0} {1} {2}",
this.IndicatorLibraryAdapter.Data[tr.IndicatorName1][counter].ToString(),
tr.CompareType.ToString(),
tr.IndicatorName2.Contains("#")
? tr.IndicatorName2.Replace("#", "")
: Convert.ToString(this.IndicatorLibraryAdapter.Data[tr.IndicatorName2][counter]));
logRowData[++logIndex] = evalData[counter].ToString("0");
logRowData[++logIndex] = buyCondition.RuleJoinTypes[i].ToString();
}
for (int i = 0; i < sellCondition.TradeRules.Count; i++)
{
tr = sellCondition.TradeRules[i];
evalData = this.Data[tr.Name];
logRowData[++logIndex] = string.Format("{0} {1} {2}",
this.IndicatorLibraryAdapter.Data[tr.IndicatorName1][counter],
tr.CompareType.ToString(),
tr.IndicatorName2.Contains("#")
? tr.IndicatorName2.Replace("#", "")
: Convert.ToString(this.IndicatorLibraryAdapter.Data[tr.IndicatorName2][counter]));
logRowData[++logIndex] = evalData[counter].ToString("0");
logRowData[++logIndex] = sellCondition.RuleJoinTypes[i].ToString();
}
this.LogTables.Rows.Add(logRowData);
logRowData = GetEmptyArray(this.LogTables.Columns.Count);
};
// returns if entry point is the last point
Action<TradeType> EnterTrade = (entryTradeType) =>
{
longEntered = entryTradeType == TradeType.longTrade;
shortEntered = entryTradeType == TradeType.shortTrade;
trade = new Trade(maxDrawDown, dollarsPerPoint, roundTripCommision, currentCapital);
trade.Enter(this.StockPoints[counter + 1], entryTradeType, Math.Min((int)(currentCapital / equityPerContract), maxContracts));
};
// returns if the needs to exit
Func<bool, int, int, bool> ExitTrade = (isStopped, indexIncreamentvalue, decrement) =>
{
trade.Exit(this.StockPoints[counter + indexIncreamentvalue], decrement, isStopped);
currentCapital = Math.Round(Math.Max(currentCapital + trade.Profit, 0D), 2);
if (trade.Profit > 0)
{
this.Winners++;
}
else if (trade.Profit < 0)
{
this.Losers++;
}
if(isStopped)
{
this.StopOuts++;
}
Trades.Add(trade);
longEntered = false;
shortEntered = false;
return currentCapital < equityPerContract;
};
#endregion Enter/Exit Trade Func
for (counter = 0; counter < this.StockPoints.Count(); counter++)
{
if (this.Cancelled)
{
this.Cancelled = false;
return Trades;
}
buySignal = buys[counter];
sellSignal = sells[counter];
stockPoint = StockPoints[counter];
currentDateTime = stockPoint.PointDateTime;
if (currentDateTime >= endDate)
{
if (longEntered || shortEntered)
{
ExitTrade(false, 0, 0);
}
break;
}
if (currentDateTime < startDate)
{
continue;
}
if (log) EnterLog();
if (currentDateTime.AddMinutes(30).Hour >= 9)
{
if (longEntered || shortEntered)
{
// exit end of day, if long/short entered or beyond specified date
if (endOfDaysIndexes.Contains(counter))
{
if (ExitTrade(false, 0, 0)) break;
}
// exit trade logic
else if ((longEntered && sellSignal) || (shortEntered && buySignal))
{
if (ExitTrade(false, 1, 5)) break;
}
//stopout
else if (stopout && ((trade.TradeType == TradeType.longTrade && trade.EntryPrice - stockPoint.Low >= stopOutValue) ||
(trade.TradeType == TradeType.shortTrade && stockPoint.High - trade.EntryPrice >= stopOutValue)))
{
if (ExitTrade(true, 1, 5)) break;
}
continue;
}
// enter trade logic
if (!(longEntered || shortEntered || endOfDaysIndexes.Contains(counter)))
{
if (buySignal && (tradeType == null || tradeType.Value == TradeType.longTrade))
{
EnterTrade(TradeType.longTrade);
}
else if (sellSignal && (tradeType == null || tradeType.Value == TradeType.shortTrade))
{
EnterTrade(TradeType.shortTrade);
}
}
}
}
return Trades;
}
public void AddTrade(TradeViewModel trade)
{
Trades.Add(trade);
Trades.OrderByDescending(t => t.Time);
RaisePropertyChangedEvent("Trades");
}
public void AddTrade(Trade Trade)
{
Trades.Add(Trade);
}
private OrderTransaction CreateTrade(OrderTransaction buytrans, OrderTransaction selltrans)
{
var l = new OrderTransaction();
if (buytrans == null && selltrans == null)
{
return(l);
}
if (buytrans.Amount >= 0)
{
throw new ArgumentException("Buy trans amount >= 0");
}
if (selltrans.Amount <= 0)
{
throw new ArgumentException("Sell trans amount <= 0");
}
if (buytrans.Quantity <= 0)
{
throw new ArgumentException("Buy quantity <= 0");
}
if (selltrans.Quantity >= 0)
{
throw new ArgumentException("Sell quantity >= 0");
}
MatchedTrade trade = new MatchedTrade
{
Id = ++tradeId,
Symbol = buytrans.Symbol,
DescriptionOfProperty = string.Format("{0} {1}", buytrans.Quantity, buytrans.Symbol),
DateAcquired = buytrans.TradeDate,
DateSoldOrDisposed = selltrans.TradeDate,
AdjustmentAmount = 0,
ReportedToIrs = true,
ReportedToMe = true,
Brokerage = selltrans.Broker,
BuyOrderId = buytrans.OrderId,
SellOrderId = selltrans.OrderId
};
// Buy quantities are positive, sell quantities are negative
// Buy Amount is negative, sell Amount is positive.
// commission and fees are always negative
if (Math.Abs(buytrans.Quantity) == Math.Abs(selltrans.Quantity))
{
trade.Quantity = buytrans.Quantity;
trade.Proceeds = Math.Abs(selltrans.Net);
trade.CostOrBasis = Math.Abs(buytrans.Net);
//Long Term Short Term
TimeSpan diff = trade.DateSoldOrDisposed.Subtract(trade.DateAcquired);
if (diff.TotalDays > 365)
{
trade.LongTermGain = true;
}
//if (trade.DateSoldOrDisposed.Year == 2014)
TotalCommission += buytrans.Commission;
TotalCommission += selltrans.Commission;
LastTradeCommission = buytrans.Commission + selltrans.Commission;
TotalProfit += trade.GainOrLoss;
//if (Math.Abs(trade.GainOrLoss) > 1000)
// throw new Exception("Invalid gain or loss");
trade.CumulativeProfit = TotalProfit;
Trades.Add(trade);
}
return(l);
}
/// <summary>
/// Processes the Spark update event provided in the EventFeedArgs and updates security properties based on the event type
/// </summary>
/// <param name="sender">Event sender</param>
/// <param name="eventFeedArgs">Event feed args</param>
internal void EventReceived(object sender, EventFeedArgs eventFeedArgs)
{
//Process event
Spark.Event eventItem = eventFeedArgs.Event;
switch (eventItem.Type)
{
//Depth update
case Spark.EVENT_NEW_DEPTH:
case Spark.EVENT_AMEND_DEPTH:
case Spark.EVENT_DELETE_DEPTH:
//Check if exchange order book exists and create if it doesn't
LimitOrderBook orderBook;
if (!OrderBooks.TryGetValue(eventFeedArgs.Exchange, out orderBook))
{
orderBook = new LimitOrderBook(eventFeedArgs.Symbol, eventFeedArgs.Exchange);
OrderBooks.Add(eventFeedArgs.Exchange, orderBook);
}
//Submit update to appropriate exchange order book
orderBook.SubmitEvent(eventItem);
if (OnDepthUpdate != null)
{
OnDepthUpdate(this, new GenericEventArgs <LimitOrderBook>(eventFeedArgs.TimeStamp, orderBook));
}
break;
//Trade update
case Spark.EVENT_TRADE:
//Create and store trade record
Trade trade = eventItem.ToTrade(eventFeedArgs.Symbol, eventFeedArgs.Exchange, eventFeedArgs.TimeStamp);
Trades.Add(trade);
if (OnTradeUpdate != null)
{
OnTradeUpdate(this, new GenericEventArgs <Trade>(eventFeedArgs.TimeStamp, trade));
}
break;
//Trade cancel
case Spark.EVENT_CANCEL_TRADE:
//Find original trade in trade record and delete
Trade cancelledTrade = eventItem.ToTrade(eventFeedArgs.TimeStamp);
Trade originalTrade = Trades.Find(x => (x.TimeStamp == cancelledTrade.TimeStamp && x.Price == cancelledTrade.Price && x.Volume == cancelledTrade.Volume));
if (originalTrade != null)
{
Trades.Remove(originalTrade);
}
break;
//Market state update
case Spark.EVENT_STATE_CHANGE:
State = ApiFunctions.ConvertToMarketState(eventItem.State);
if (OnMarketStateUpdate != null)
{
OnMarketStateUpdate(this, new GenericEventArgs <MarketState>(eventFeedArgs.TimeStamp, State));
}
break;
//Market quote update (change to best market bid-ask prices)
case Spark.EVENT_QUOTE:
if (OnQuoteUpdate != null)
{
LimitOrderBook depth = OrderBooks[eventFeedArgs.Exchange];
MarketQuote quote = new MarketQuote(eventFeedArgs.Symbol, eventFeedArgs.Exchange, depth.BidPrice, depth.AskPrice, eventFeedArgs.TimeStamp);
OnQuoteUpdate(this, new GenericEventArgs <MarketQuote>(eventFeedArgs.TimeStamp, quote));
}
break;
//IAP (Indicative Auction Price) Update
case Spark.EVENT_AUCTION_PRICE:
break;
default:
//Console.WriteLine(eventItem.ToOutputString());
break;
}
}
public void AddTrade(Trade trade)
{
Trades.Add(trade);
}
public void RegisterTrade(ExchangeTrade trade)
{
Trades.Add(trade);
}
private async System.Threading.Tasks.Task ExecuteLoadTradesCommand()
{
if (IsBusy)
{
return;
}
IsRefreshing = false;
IsBusy = true;
var usr = AuthService.UserToken.User;
try
{
Trades.Clear();
var items = await DataService.GetItemsAsync <ScheduleTrade>("scheduleTrades" + (ForUser ? "?forUser=true" : "?status=" + ((int)Constants.TRADE_STATUS.PENDING_APPROVAL).ToString()));
NoTrades = !items.Data.Any();
OnPropertyChanged("NoTrades");
foreach (var item in items.Data.OrderByDescending(d => d.Schedule.ScheduleDateValue))
{
var tradeListItem = new TradeListItem();
tradeListItem.ScheduleTrade = item;
tradeListItem.Schedule = GetItemForSchedule(item.Schedule);
if (item.TradeForScheduleId != null)
{
tradeListItem.ToSchedule = GetItemForSchedule(item.TradeForSchedule);
}
tradeListItem.InfoColumn = new DisplayItem();
tradeListItem.InfoColumn.Tag = false;
tradeListItem.AcceptApproveText = "";
tradeListItem.DeclineDenyText = "";
if (ForUser && item.TradeStatus == (int)Constants.TRADE_STATUS.REQUESTED && item.Schedule.UserIdValue == usr.UserIdValue)
{
tradeListItem.InfoColumn.Tag = true;
tradeListItem.AcceptApproveText = AcceptText;
tradeListItem.DeclineDenyText = DeclineText;
}
else if (!ForUser && item.TradeStatus == (int)Constants.TRADE_STATUS.PENDING_APPROVAL)
{
tradeListItem.InfoColumn.Tag = true;
tradeListItem.AcceptApproveText = ApproveText;
tradeListItem.DeclineDenyText = DenyText;
}
tradeListItem.InfoColumn.Line1 = item.TradeUser == null ? "" : item.TradeUser.DisplayName + " - ";
switch (item.TradeStatusValue)
{
case (int)Constants.TRADE_STATUS.SUBMITTED:
tradeListItem.Color = Color.LightGray;
tradeListItem.InfoColumn.Line1 += "Posted";
break;
case (int)Constants.TRADE_STATUS.REQUESTED:
tradeListItem.Color = Color.Yellow;
tradeListItem.InfoColumn.Line1 += "Requested";
break;
case (int)Constants.TRADE_STATUS.PENDING_APPROVAL:
tradeListItem.Color = Color.Green;
tradeListItem.InfoColumn.Line1 += "Pending Approval";
break;
case (int)Constants.TRADE_STATUS.APPROVED:
tradeListItem.Color = Color.Blue;
tradeListItem.InfoColumn.Line1 += "Approved";
break;
case (int)Constants.TRADE_STATUS.DENIED:
tradeListItem.Color = Color.Red;
tradeListItem.InfoColumn.Line1 += "Denied";
break;
default:
tradeListItem.Color = Color.Black;
break;
}
Trades.Add(tradeListItem);
}
}
catch (Exception ex)
{
IsBusy = false;
ExceptionHelper.ShowException(ex);
}
finally
{
IsBusy = false;
}
}
/// <summary>Called when new data is received</summary>
public override void Step()
{
var sym = Instrument.Symbol;
SyncTrades();
// If not holding a position yet, look for a good entry
if (Trades.Count == 0)
{
// Look for a good entry point
var trade = FindEntry();
if (trade == null)
{
return;
}
// Record the initial risk
BalanceRisked = sym.QuoteToAcct(trade.StopLossRel() * trade.Volume);
// Open the position
var pos = Broker.CreateOrder(trade);
if (pos != null)
{
Trades.Add(new Trade(Instrument, pos));
}
}
// Otherwise, we have one or more live positions
else
{
// Test the nett position:
var net = NetPosition;
// If we're in the green..
if (net > 0)
{
// Let it run
return;
}
else if (-net >= BalanceRisked)
{
// Cut and run
CloseOut();
}
else
{
//// If we've reached a large proportion of the SL value,
//// open a revenge trade in the opposite direction.
//var revenge =
// (Trades.Count == 1 && -net > BalanceRisked * 0.5) ||
// (Trades.Count == 2 && -net > BalanceRisked * 0.8);
//if (revenge)
//{
// var last = Trades.Back();
// var trade = new Trade(Bot, Instrument, last.TradeType.Opposite());
// var pos = Broker.CreateOrder(trade);
// if (pos != null)
// Trades.Add(new Trade(Instrument, pos));
//}
}
}
}
