XmppStatistics.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.Attributes;
using Waher.Things.Queries;
 
namespace Waher.Service.IoTBroker.Sources.Protocols.Commands
{
    public class XmppStatistics : ICommand
    {
        [Page(1, "Time", 150)]
        [Header(2, "From:")]
        [ToolTip(3, "Search for records from this point in time.")]
        public DateTime From = DateTime.MinValue;
 
        [Page(1, "Time", 150)]
        [Header(4, "To:")]
        [ToolTip(5, "Search for records to this point in time.")]
        public DateTime To = DateTime.MaxValue;
 
        public string CommandID => "Statistics";
        public CommandType Type => CommandType.Query;
        public string SortCategory => "Protocols";
        public string SortKey => "Statistics";
 
        public Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppStatistics), 6, "Statistics...");
        }
 
        public Task<bool> CanExecuteAsync(RequestOrigin Caller)
        {
            return XmppServerModule.IsAdmin(Caller.From);
        }
 
        public ICommand Copy()
        {
            return new XmppStatistics()
            {
                From = this.From,
                To = this.To
            };
        }
 
        public Task ExecuteCommandAsync()
        {
            throw new NotSupportedException();
        }
 
        public Task<string> GetConfirmationStringAsync(Language Language)
        {
            return Task.FromResult(string.Empty);
        }
 
        public Task<string> GetFailureStringAsync(Language Language)
        {
            return Task.FromResult(string.Empty);
        }
 
        public Task<string> GetSuccessStringAsync(Language Language)
        {
            return Task.FromResult(string.Empty);
        }
 
        public 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();
                await Query.SetTitle(await Language.GetStringAsync(typeof(XmppStatistics), 15, "Requests"));
 
                if (this.To < this.From)
                {
                    DateTime Temp = this.To;
                    this.To = this.From;
                    this.From = Temp;
                }
 
                List<Filter> Filters = new List<Filter>();
                IEnumerable<XmppStatistic> Records;
 
                if (this.From > DateTime.MinValue)
                    Filters.Add(new FilterFieldGreaterOrEqualTo("Timestamp", this.From));
 
                if (this.To < DateTime.MaxValue)
                    Filters.Add(new FilterFieldLesserOrEqualTo("Timestamp", this.To));
 
                await Query.SetStatus(await Language.GetStringAsync(typeof(XmppStatistics), 8, "Searching database..."));
 
                switch (Filters.Count)
                {
                    case 0:
                        Records = await Database.Find<XmppStatistic>("Timestamp");
                        break;
 
                    case 1:
                        Records = await Database.Find<XmppStatistic>(Filters[0], "Timestamp");
                        break;
 
                    default:
                        Records = await Database.Find<XmppStatistic>(new FilterAnd(Filters.ToArray()), "Timestamp");
                        break;
                }
 
                string Header = await Language.GetStringAsync(typeof(XmppStatistics), 17, "XMPP Statistics");
                await Query.BeginSection(Header);
                await Query.NewTable("Statistics", Header, new Column[]
                {
                    new Column("Start", await Language.GetStringAsync(typeof(XmppStatistics), 10, "Start"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("Timestamp", await Language.GetStringAsync(typeof(XmppStatistics), 11, "Timestamp"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("Requests", await Language.GetStringAsync(typeof(XmppStatistics), 16, "#Stanzas"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("Rx", await Language.GetStringAsync(typeof(XmppStatistics), 13, "#Rx"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("Tx", await Language.GetStringAsync(typeof(XmppStatistics), 14, "#Tx"),
                        null, null, null, null, ColumnAlignment.Left, null)
                });
 
                foreach (XmppStatistic Rec in Records)
                {
                    await Query.NewRecords("Statistics", new Record(new object[]
                    {
                        Rec.Start,
                        Rec.Timestamp,
                        Rec.NrStanzas,
                        Rec.NrBytesRx,
                        Rec.NrBytesTx
                    }));
                }
 
                await Query.TableDone("Statistics");
                await Query.EndSection();
            }
            catch (Exception ex)
            {
                await Query.LogMessage(ex);
            }
            finally
            {
                await Query.Done();
            }
        }
 
    }
}