private IndicatorResult GenerateResult(IPriceSeries shortTermPoints, IPriceSeries longTermPoints)
{
var signals = Indicator.SignalGenerationStrategy.Generate(shortTermPoints, longTermPoints);
var reportData = new GenericIndicatorReport.Data()
{
SignalOfDayUnderAnalysis = GetCurrentSignal(signals, longTermPoints),
Prices = myPrices,
Signals = signals
};
reportData.Points[Indicator.ShortTerm.Name] = shortTermPoints;
reportData.Points[Indicator.LongTerm.Name] = longTermPoints;
var result = new IndicatorResult(Indicator.Name, Stock, reportData.SignalOfDayUnderAnalysis);
if (Context.GenerateHistoricSignals)
{
result.Signals = signals;
}
result.Report = new DoubleCrossoverReport(Indicator, Stock, reportData);
return(result);
}
private void RenderIndicatorResult(IndicatorResult result, IRenderingContext context)
{
context.Document.WriteLine("<h2>Indicators</h2>");
RenderIndicatorSummary(result, context);
RenderIndicatorDetails(result.Report, context);
}
private IndicatorResult GenerateMissingDataResult(IIndicatorContext context)
{
var result = new IndicatorResult(Name, context.Stock, Signal.None);
result.Report = new MissingDataReport(Name);
return(result);
}
public virtual IndicatorResult Merge(KeyValuePair <DateTime, List <IndicatorResult> > groupedItems)
{
var result = new IndicatorResult(groupedItems.Key);
var value = groupedItems.Value.Sum(v => v.Value);
result.Value = Math.Round(value, 4);
return(result);
}
private static void RenderIndicatorSummary(IndicatorResult result, IRenderingContext context)
{
context.Document.WriteLine("<table>");
context.Document.WriteLine("<tr><td>Signal</td><td>{0}</td></tr>", HtmlRenderingUtils.GetDisplayText(result.Signal));
context.Document.WriteLine("<tr><td>Gain/Risk ratio</td><td>{0}</td></tr>", HtmlRenderingUtils.GetDisplayText(result.GainRiskRatio));
context.Document.WriteLine("<tr><td>Expected gain</td><td>{0}</td></tr>", HtmlRenderingUtils.GetDisplayText(result.ExpectedGain));
context.Document.WriteLine("</table>");
}
private void RenderIndicatorSummeryRow(IndicatorResult result, IRenderingContext context)
{
context.Document.WriteLine("<tr>");
context.Document.WriteLine("<td>{0}</td>", result.Indicator);
RenderSignal(result, context);
context.Document.WriteLine("<td align=\"right\">{0}</td>", HtmlRenderingUtils.GetDisplayText(result.GainRiskRatio));
context.Document.WriteLine("<td align=\"right\">{0}</td>", HtmlRenderingUtils.GetDisplayText(result.ExpectedGain));
context.Document.WriteLine("</tr>");
}
public SystemResult(string system, StockHandle stock, IPriceSeries prices, IndicatorResult indicatorResult)
{
System = system;
Stock = stock;
Prices = prices;
Signal = indicatorResult.Signal;
ExpectedGain = indicatorResult.ExpectedGain;
GainRiskRatio = indicatorResult.GainRiskRatio;
Signals = indicatorResult.Signals;
}
public void Calculate()
{
IndicatorResult = new IndicatorResult(new HandIndicator(new ObservableCollection <FingerIndicator>()
{
FingerL1, FingerL2, FingerL3, FingerL4, FingerL5
}, ATDL),
new HandIndicator(new ObservableCollection <FingerIndicator>()
{
FingerR1, FingerR2, FingerR3, FingerR4, FingerR5
}, ATDR), Year, SelectedGender);
RaisePropertyChanged(nameof(IndicatorResult));
}
/// <summary>
/// Record High Percent = {New Highs / (New Highs + New Lows)} x 100
/// High-Low Index = 10 - day SMA of Record High Percent
/// </summary>
/// <returns></returns>
public override IndicatorResult Merge(KeyValuePair <DateTime, List <IndicatorResult> > groupedItems)
{
var newHigh = groupedItems.Value.Select(v => v.AsNHNLIndicatorResult()).Sum(r => r.NewHigh);
var newLow = groupedItems.Value.Select(v => v.AsNHNLIndicatorResult()).Sum(r => r.NewLow);
var result = new IndicatorResult(groupedItems.Key).AsNHNLIndicatorResult();
result.NewLow = newLow;
result.NewHigh = newHigh;
return(result.Result);
}
private void RenderSignal(IndicatorResult result, IRenderingContext context)
{
if (result.Report == null)
{
context.Document.WriteLine("<td>{0}</td>", HtmlRenderingUtils.GetDisplayText(result.Signal));
}
else
{
using (var childCtx = context.CreateChildContext(result.Indicator, result.Report.Name + ".html"))
{
childCtx.Render(result.Report);
context.Document.WriteLine("<td><a href=\"{0}\">{1}</a></td>",
childCtx.RelativeDocumentUrl(context), HtmlRenderingUtils.GetDisplayText(result.Signal));
}
}
}
public override List <IndicatorResult> Combine(List <IndicatorResult> indicatorResults)
{
var result = new List <IndicatorResult>();
foreach (var indicatorResult in indicatorResults)
{
var item = new IndicatorResult(indicatorResult.Date);
var values = indicatorResult.AsNHNLIndicatorResult();
item.Value = Math.Round(CalculateNHNL(values.NewHigh, values.NewLow), 4);
result.Add(item);
}
var sma = new SMA();
var smaResult = sma.Calculate(result.Select(c => new QuotesModel
{
Date = c.Date,
Close = c.Value
}).ToList(), 10);
return(smaResult);
}
public bool CheckRuleSets(IEnumerable <RuleSet> ruleSets, List <Candle> candles)
{
int passedRuleSets = 0; // if one of the rulesets pass then we got a signal
foreach (RuleSet ruleSet in ruleSets)
{
int passedRules = 0;
List <IIndicatorResult> passedResults = new List <IIndicatorResult>();
foreach (Rule rule in ruleSet.Rules)
{
IndicatorResult result = GetInidcatorResult(rule, candles);
if (result.Result)
{
passedResults.Add(result);
++passedRules;
}
}
if (passedRules == ruleSet.Rules.Count)
{
_logger.Info("");
++passedRuleSets;
Log($"All rules for {ruleSet.RuleSide.ToString().ToUpper()} ruleset passed { ruleSet.Indicator.IndicatorType.ToString() }, {ruleSet.Indicator.Bot.Name} ..");
foreach (IIndicatorResult indicatorResult in passedResults)
{
Log(indicatorResult.Message);
}
_logger.Info("");
}
}
return(passedRuleSets > 0);
}
private IndicatorResult GenerateResult(IPriceSeries points)
{
var signals = Indicator.SignalGenerationStrategy.Generate(myPrices, points);
var reportData = new GenericIndicatorReport.Data()
{
SignalOfDayUnderAnalysis = GetCurrentSignal(signals, points),
Prices = myPrices,
Signals = signals
};
reportData.Points[Indicator.Name] = points;
var result = new IndicatorResult(Indicator.Name, Stock, reportData.SignalOfDayUnderAnalysis);
if (Context.GenerateHistoricSignals)
{
result.Signals = signals;
}
result.Report = new SmaReport(Indicator, Stock, reportData);
return(result);
}
public OrderManager(IndicatorResult indicatorResult)
{
_indicatorResult = indicatorResult;
}
public Task <Result <EditIndicatorResponse> > Handle(EditIndicatorResultsCommand request, CancellationToken cancellationToken)
{
try
{
var reportingPeriod = _airUnitOfWork.Repository <ReportingPeriod>()
.Get(x => x.Id == request.ReportingPeriodId).SingleOrDefault();
if (reportingPeriod == null)
{
return(Task.FromResult(Result <EditIndicatorResponse> .Invalid($"Reporting Period Id {request.ReportingPeriodId} not found")));
}
reportingPeriod.Update(request.ReportingDate);
_airUnitOfWork.Repository <ReportingPeriod>().Update(reportingPeriod);
var indicatorResults = _airUnitOfWork.Repository <IndicatorResult>()
.Get(x => x.ReportingPeriodId == request.ReportingPeriodId).AsEnumerable();
if (!indicatorResults.Any())
{
return(Task.FromResult(Result <EditIndicatorResponse> .Invalid($"Indicator results for period Id {request.ReportingPeriodId} not found")));
}
if (request.IndicatorResults == null || !request.IndicatorResults.Any())
{
return(Task.FromResult(Result <EditIndicatorResponse> .Invalid("Indicator Results to be edited not found")));
}
var updatedIndicatorResults = indicatorResults.Where(x =>
request.IndicatorResults.Any(i => i.Id == x.IndicatorId && (x.ResultNumeric != i.ResultNumeric || x.ResultText != x.ResultText)))
.AsEnumerable();
foreach (var result in updatedIndicatorResults)
{
var newResultValue = request.IndicatorResults.SingleOrDefault(x => x.Id == result.IndicatorId);
if (newResultValue == null)
{
var IndicatorResult = new IndicatorResult(reportingPeriod.Id, result.Id, result.ResultText, result.ResultNumeric, reportingPeriod.CreatedBy);
_airUnitOfWork.Repository <IndicatorResult>().AddRangeAsync(indicatorResults);
_airUnitOfWork.SaveAsync();
}
else
{
result.UpdateResult(newResultValue.ResultNumeric, newResultValue.ResultText);
_airUnitOfWork.Repository <IndicatorResult>().Update(result);
}
}
_airUnitOfWork.Save();
return(Task.FromResult(Result <EditIndicatorResponse> .Valid(new EditIndicatorResponse
{
Message = $"Indicator results for report periodId: {request.ReportingPeriodId} and report month of {request.ReportingDate.Month} and reporting year of " +
$" {request.ReportingDate.Year} updated succesfully",
ReportingPeriodId = request.ReportingPeriodId
})));
}
catch (Exception ex)
{
string message = $"An error occured while editing indicator results for reporting periodId {request.ReportingPeriodId}";
_logger.Error(ex, message);
return(Task.FromResult(Result <EditIndicatorResponse> .Invalid(message)));
}
}
