public async Task <IActionResult> GetAnalysis([FromRoute] string symbol)
{
var buyAnalysis = new TradeAnalysis();
var sellAnalysis = new TradeAnalysis();
var share = await _shareRepository.Query().Where(p => p.Symbol.Equals(symbol)).FirstOrDefaultAsync();
var buyTrades = share?.Trades?.Where(p => p.Action.Equals(OperationEnum.Buy)).ToList();
var sellTrades = share?.Trades?.Where(p => p.Action.Equals(OperationEnum.Sell)).ToList();
if (buyTrades != null)
{
buyAnalysis.Sum = buyTrades.Sum(p => p.TotalPrice);
buyAnalysis.Average = buyTrades.Average(p => p.TotalPrice);
buyAnalysis.Minimum = buyTrades.Min(p => p.TotalPrice);
buyAnalysis.Maximum = buyTrades.Max(p => p.TotalPrice);
}
if (sellTrades != null)
{
sellAnalysis.Sum = sellTrades.Sum(p => p.TotalPrice);
sellAnalysis.Average = sellTrades.Average(p => p.TotalPrice);
sellAnalysis.Minimum = sellTrades.Min(p => p.TotalPrice);
sellAnalysis.Maximum = sellTrades.Max(p => p.TotalPrice);
}
return(Ok(new { buyAnalysis, sellAnalysis }));
}
public async Task <IActionResult> GetAnalysis([FromRoute] string symbol)
{
var list = new List <TradeAnalysis>();
var tradeBuys = _tradeRepository.GetTradesBySymbol(symbol);
var sumForBuy = tradeBuys.GroupBy(x => x.Action).Select(t => new { action = t.Key, sum = t.Sum(i => i.Price), avarage = t.Average(i => i.Price), max = t.Max(i => i.Price), min = t.Min(i => i.Price) });
if (sumForBuy.ToList().Count > 0)
{
foreach (var item in sumForBuy)
{
TradeAnalysis tradeAnalysis = new TradeAnalysis();
tradeAnalysis.Maximum = item.max;
tradeAnalysis.Minimum = item.min;
tradeAnalysis.Sum = item.sum;
tradeAnalysis.Average = item.avarage;
tradeAnalysis.Action = item.action;
list.Add(tradeAnalysis);
}
return(Ok(list));
}
else
{
return(NotFound());
}
}
public async Task <IActionResult> GetAnalysis([FromRoute] int portFolioid)
{
var shares = _tradeRepository.Query().Where(x => x.Symbol.Equals(portFolioid));
var q_sell = shares.Where(i => i.Action.Equals("SELL"));
var q_buy = shares.Where(i => i.Action.Equals("BUY"));
TradeAnalysis sell = new TradeAnalysis();
if (q_sell.Count() > 0)
{
sell.Sum = q_sell.Sum(i => i.NoOfShares);
sell.Average = q_sell.Average(i => i.NoOfShares);
sell.Maximum = q_sell.Max(i => i.NoOfShares);
sell.Minimum = q_sell.Min(i => i.NoOfShares);
}
sell.Action = "SELL";
TradeAnalysis buy = new TradeAnalysis();
if (q_buy.Count() > 0)
{
buy.Sum = q_buy.Sum(i => i.NoOfShares);
buy.Average = q_buy.Average(i => i.NoOfShares);
buy.Maximum = q_buy.Max(i => i.NoOfShares);
buy.Minimum = q_buy.Min(i => i.NoOfShares);
}
buy.Action = "BUY";
var result = new List <TradeAnalysis>();
result.Add(sell);
result.Add(buy);
return(Ok(result));
}
public async Task <IActionResult> GetAnalysis([FromRoute] string symbol)
{
var result = new List <TradeAnalysis>();
var stats = _tradeRepository.Query()
.Where(x => x.Symbol == symbol)
.GroupBy(x => x.Action)
.Select(x => new
{
sumTrades = x.Sum(z => z.NoOfShares),
avgTrades = x.Average(z => z.NoOfShares),
maxValue = x.Max(z => z.NoOfShares),
minValue = x.Min(z => z.NoOfShares),
actionValue = x.Key
}).ToList();
foreach (var item in stats)
{
TradeAnalysis ta = new TradeAnalysis();
ta.Sum = item.sumTrades;
ta.Average = item.avgTrades;
ta.Maximum = item.maxValue;
ta.Minimum = item.minValue;
ta.Action = item.actionValue;
result.Add(ta);
}
return(Ok(result));
}
public void ShouldTestTradeAnalysis()
{
TradeAnalysis tradeAnalysis = new TradeAnalysis();
tradeAnalysis.Action = "BUY";
tradeAnalysis.Sum = 200;
tradeAnalysis.Maximum = 100;
tradeAnalysis.Minimum = 100;
tradeAnalysis.Average = 100;
CheckPropertyValidation cpv = new CheckPropertyValidation();
var errorCount = cpv.myValidation(tradeAnalysis).Count;
Assert.AreEqual(0, errorCount);
}
public async Task <IActionResult> GetAnalysis([FromRoute] string symbol)
{
var result = new List <TradeAnalysis>();
TradeAnalysis ta = new TradeAnalysis();
var tradeBuy = _tradeRepository.Query().Where(x => x.Symbol.Equals(symbol) && x.Action.Equals("BUY"));
var tradeSell = _tradeRepository.Query().Where(x => x.Symbol.Equals(symbol) && x.Action.Equals("SELL"));
List <int> trdNoSBuy = new List <int>();
List <int> trdNoSSell = new List <int>();
foreach (var t in tradeBuy)
{
trdNoSBuy.Add(t.NoOfShares);
}
foreach (var t in tradeSell)
{
trdNoSSell.Add(t.NoOfShares);
}
if (!trdNoSBuy.Count.Equals(0))
{
ta.Maximum = trdNoSBuy.Max();
ta.Minimum = trdNoSBuy.Min();
ta.Sum = trdNoSBuy.Sum();
ta.Average = trdNoSBuy.Average();
ta.Action = "BUY";
result.Add(ta);
}
ta = new TradeAnalysis();
if (!trdNoSSell.Count.Equals(0))
{
ta.Maximum = trdNoSSell.Max();
ta.Minimum = trdNoSSell.Min();
ta.Sum = trdNoSSell.Sum();
ta.Average = trdNoSSell.Average();
ta.Action = "SELL";
result.Add(ta);
}
return(Ok(result));
}
public async Task <IActionResult> GetAnalysis([FromRoute] string symbol)
{
var list = new List <TradeAnalysis>();
//group actions
var groupActions = _tradeRepository.Query().Where(x => x.Symbol.Equals(symbol)).GroupBy(x => x.Action);
foreach (var ga in groupActions)
{
var ta = new TradeAnalysis
{
Maximum = ga.Max(x => x.NoOfShares),
Minimum = ga.Min(x => x.NoOfShares),
Average = (decimal)ga.Average(x => x.NoOfShares),
Sum = ga.Sum(x => x.NoOfShares),
Action = ga.Select(x => x.Action).FirstOrDefault()
};
list.Add(ta);
}
return(Ok(list));
}
