SampleStatisticsCommand.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Markdown;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Language;
using Waher.Runtime.Statistics;
using Waher.Script;
using Waher.Script.Graphs;
using Waher.Script.Objects;
using Waher.Script.Units;
using Waher.Things;
using Waher.Things.Attributes;
using Waher.Things.Queries;
 
namespace Waher.Service.IoTBroker.Sources.Reports.Performance.Commands
{
    public class SampleStatisticsCommand : ExecuteServerAdminReport
    {
        private readonly SampleStatisticsCommand[] embeddedReports;
        private readonly string performanceId;
        private readonly int titleId;
        private readonly string title;
        private readonly string unit;
        private readonly string windowSize;
        private readonly double? min;
        private readonly double? max;
 
        public SampleStatisticsCommand(string PerformanceId, int TitleId, string Title, string Unit,
            double? Min, double? Max, string WindowSize, ServerAdminReportNode Report, 
            params SampleStatisticsCommand[] EmbeddedReports)
            : base(Report)
        {
            this.performanceId = PerformanceId;
            this.titleId = TitleId;
            this.title = Title;
            this.unit = Unit;
            this.min = Min;
            this.max = Max;
            this.windowSize = WindowSize;
            this.embeddedReports = EmbeddedReports;
        }
 
        [Page(1, "Time", 150)]
        [Header(2, "From:")]
        [ToolTip(3, "Search for records from this point in time.")]
        public DateTime From = DateTime.Today.AddDays(-1);
 
        [Page(1, "Time", 150)]
        [Header(4, "To:")]
        [ToolTip(5, "Search for records to this point in time.")]
        public DateTime To = DateTime.Today.AddDays(1);
 
        public override Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(SampleStatisticsCommand), 6, "Statistics...");
        }
 
        public override ICommand Copy()
        {
            return new SampleStatisticsCommand(this.performanceId, this.titleId, this.title, 
                this.unit, this.min, this.max, this.windowSize, (ServerAdminReportNode)this.Report,
                this.embeddedReports)
            {
                From = this.From,
                To = this.To
            };
        }
 
        public override Task StartQueryExecutionAsync(Query Query, Language Language)
        {
            this.Execute(Query, Language);
            return Task.CompletedTask;
        }
 
        private async void Execute(Query Query, Language Language)
        {
            try
            {
                await Query.Start();
 
                string Title = await Language.GetStringAsync(typeof(SampleStatisticsCommand), this.titleId, this.title);
                await Query.SetTitle(Title);
                await Query.BeginSection(Title);
 
                if (this.embeddedReports is null || this.embeddedReports.Length == 0)
                {
                    await ReportGraph(Query, Language, this.From, this.To,
                        this.performanceId, this.titleId, this.title, this.unit,
                        this.min, this.max, this.windowSize);
                }
                else
                {
                    foreach (SampleStatisticsCommand Report in this.embeddedReports)
                    {
                        await ReportGraph(Query, Language, this.From, this.To,
                            Report.performanceId, Report.titleId, Report.title,
                            Report.unit, this.min, this.max, Report.windowSize);
                    }
                }
            
                await Query.EndSection();
            }
            catch (Exception ex)
            {
                await Query.LogMessage(ex);
            }
            finally
            {
                await Query.Done();
            }
        }
 
        private static async Task ReportGraph(Query Query, Language Language,
            DateTime From, DateTime To, string PerformanceId, int TitleId,
            string DefaultTitle, string Unit, double? MinValue, double? MaxValue,
            string WindowSize)
        {
            try
            {
                if (To < From)
                {
                    DateTime Temp = To;
                    To = From;
                    From = Temp;
                }
 
                List<Filter> Filters = new List<Filter>()
                {
                    new FilterFieldEqualTo("Id", PerformanceId)
                };
 
                if (From > DateTime.MinValue)
                    Filters.Add(new FilterFieldGreaterOrEqualTo("Start", From));
 
                if (To < DateTime.MaxValue)
                    Filters.Add(new FilterFieldLesserThan("Start", To));
 
                await Query.SetStatus(await Language.GetStringAsync(typeof(SampleStatisticsCommand), 9, "Searching database..."));
 
                IEnumerable<SampleStatistic> Records;
 
                if (Filters.Count == 1)
                    Records = await Database.Find<SampleStatistic>(Filters[0], "Start");
                else
                    Records = await Database.Find<SampleStatistic>(new FilterAnd(Filters.ToArray()), "Start");
 
                string Title = await Language.GetStringAsync(typeof(SampleStatisticsCommand), TitleId, DefaultTitle);
                await Query.BeginSection(Title);
                try
                {
                    int NrRecords = 0;
 
                    foreach (SampleStatistic Record in Records)
                        NrRecords++;
 
                    const int MaxRecords = 50;
                    bool ShowTable = NrRecords <= MaxRecords;
                    Unit ParsedUnit = Script.Units.Unit.Parse(Unit);
 
                    if (ShowTable)
                    {
                        await Query.NewTable("Statistics", Title, new Column[]
                        {
                            new Column("Start", await Language.GetStringAsync(typeof(SampleStatisticsCommand), 10, "Start"),
                                null, null, null, null, ColumnAlignment.Left, null),
                            new Column("Stop", await Language.GetStringAsync(typeof(SampleStatisticsCommand), 11, "Stop"),
                                null, null, null, null, ColumnAlignment.Left, null),
                            new Column("Count", await Language.GetStringAsync(typeof(SampleStatisticsCommand), 12, "Count"),
                                null, null, null, null, ColumnAlignment.Right, null),
                            new Column("Mean", await Language.GetStringAsync(typeof(SampleStatisticsCommand), 13, "Mean"),
                                null, null, null, null, ColumnAlignment.Right, null),
                            new Column("Variance", await Language.GetStringAsync(typeof(SampleStatisticsCommand), 14, "Variance"),
                                null, null, null, null, ColumnAlignment.Right, null),
                            new Column("StdDev", await Language.GetStringAsync(typeof(SampleStatisticsCommand), 15, "StdDev"),
                                null, null, null, null, ColumnAlignment.Right, null),
                            new Column("Min", await Language.GetStringAsync(typeof(SampleStatisticsCommand), 16, "Min"),
                                null, null, null, null, ColumnAlignment.Right, null),
                            new Column("Max", await Language.GetStringAsync(typeof(SampleStatisticsCommand), 17, "Max"),
                                null, null, null, null, ColumnAlignment.Right, null)
                        });
 
                        foreach (SampleStatistic Rec in Records)
                        {
                            await Query.NewRecords("Statistics", new Record(new object[]
                            {
                                Rec.Start,
                                Rec.Stop,
                                Rec.Count,
                                Rec.Mean.HasValue ? new PhysicalQuantity(Rec.Mean.Value, ParsedUnit) : null,
                                Rec.Variance,
                                Rec.StdDev,
                                Rec.Min.HasValue ? new PhysicalQuantity(Rec.Min.Value, ParsedUnit) : null,
                                Rec.Max.HasValue ? new PhysicalQuantity(Rec.Max.Value, ParsedUnit) : null
                            }));
                        }
 
                        await Query.TableDone("Statistics");
                    }
                    else
                    {
                        StringBuilder Markdown = new StringBuilder();
 
                        Markdown.Append(await Language.GetStringAsync(typeof(SampleStatisticsCommand), 18, "Number of records:"));
                        Markdown.Append(" **");
                        Markdown.Append(NrRecords.ToString());
                        Markdown.Append("**. (");
                        Markdown.Append((await Language.GetStringAsync(typeof(SampleStatisticsCommand), 19, "Table shown if %0% records or less.")).Replace("%0%", MaxRecords.ToString()));
                        Markdown.Append(")");
 
                        await Query.NewObject(new MarkdownContent(Markdown.ToString()));
                    }
 
                    await Query.SetStatus(await Language.GetStringAsync(typeof(SampleStatisticsCommand), 20, "Preparing graph."));
 
                    StringBuilder sb = new StringBuilder();
 
                    sb.AppendLine("StepX:=join([foreach Rec in RS do [Rec.Start,Rec.Stop]]);");
                    sb.AppendLine("StepMean:=join([foreach Rec in RS do [Rec.Mean,Rec.Mean]]);");
                    sb.AppendLine("RS2:=[Rec in RS:exists(Rec.StdDev)];");
 
                    if (MinValue.HasValue)
                    {
                        sb.Append("SubSigma(x,s):=Max(x-s,");
                        sb.Append(Expression.ToString(MinValue.Value));
                        sb.AppendLine(");");
                    }
                    else
                        sb.AppendLine("SubSigma(x,s):=x-s;");
 
                    if (MaxValue.HasValue)
                    {
                        sb.Append("AddSigma(x,s):=Min(x+s,");
                        sb.Append(Expression.ToString(MaxValue.Value));
                        sb.AppendLine(");");
                    }
                    else
                        sb.AppendLine("AddSigma(x,s):=x+s;");
 
                    sb.AppendLine("G:=sum([foreach Rec in RS do polygon2d([a:=Rec.Start,b:=Rec.Stop,b,a],[a:=Rec.Min,a,b:=Rec.Max,b],'Orange')])+");
                    sb.AppendLine("sum([foreach Rec in RS2 do polygon2d([a:=Rec.Start,b:=Rec.Stop,b,a],[a:=SubSigma(Rec.Mean,2*Rec.StdDev),a,b:=AddSigma(Rec.Mean,2*Rec.StdDev),b],'OrangeRed')])+");
                    sb.AppendLine("sum([foreach Rec in RS2 do polygon2d([a:=Rec.Start,b:=Rec.Stop,b,a],[a:=SubSigma(Rec.Mean,Rec.StdDev),a,b:=AddSigma(Rec.Mean,Rec.StdDev),b],'Red')])+");
                    sb.AppendLine("plot2dline(StepX,StepMean,'Black');");
                    sb.AppendLine("G.Title:=Title;");
                    sb.AppendLine("G.LabelX:=LabelX;");
                    sb.AppendLine("G.LabelY:=LabelY; ");
                    sb.AppendLine("G");
 
                    await Query.NewObject(await Expression.EvalAsync(
                        sb.ToString(),
                        new Variables()
                        {
                            { Graph.GraphWidthVariableName, 1280 },
                            { Graph.GraphHeightVariableName, 500 },
                            { "RS", Records },
                            { "Title", Title },
                            { "LabelX", await Language.GetStringAsync(typeof(SampleStatisticsCommand), 1, "Time") },
                            { "LabelY", Unit }
                        }));
                    await Query.NewObject(await Expression.EvalAsync(
                        "legend(['Mean ('+WindowSize+')'," +
                        "'±σ ('+WindowSize+')'," +
                        "'±2σ ('+WindowSize+')'," +
                        "'Min-Max ('+WindowSize+')']," +
                        "['Black','Red','OrangeRed','Orange'],'White',4)",
                        new Variables()
                        {
                            { "WindowSize", WindowSize }
                        }));
 
                    await Query.SetStatus(string.Empty);
                }
                catch (Exception ex)
                {
                    await Query.LogMessage(ex);
                }
                finally
                {
                    await Query.EndSection();
                }
            }
            catch (Exception ex)
            {
                await Query.LogMessage(ex);
            }
        }
    }
}