SearchEventsCommand.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Events.Persistence;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Collections;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.Attributes;
using Waher.Things.Queries;
 
namespace Waher.Service.IoTBroker.Sources.Reports.Events.Commands
{
    public class SearchEventsCommand : ExecuteServerAdminReport
    {
        public SearchEventsCommand(SearchEventLogNode ReportNode)
            : base(ReportNode)
        {
        }
 
        [Page(2, "Pagination", 200)]
        [Header(3, "Offset:")]
        [ToolTip(4, "Skip this number of objects in the result set.")]
        [Required]
        [Range(0, int.MaxValue)]
        public int Offset = 0;
 
        [Page(2, "Pagination", 200)]
        [Header(5, "Max Count:")]
        [ToolTip(6, "Maximum number of objects to return.")]
        [Required]
        [Range(1, int.MaxValue)]
        public int MaxCount = 1000;
 
        [Page(7, "Time", 150)]
        [Header(8, "From:")]
        [ToolTip(9, "Search for events from this point in time.")]
        public DateTime From = CurrentMinute.AddHours(-1);
 
        [Page(7, "Time", 150)]
        [Header(10, "To:")]
        [ToolTip(11, "Search for events to this point in time.")]
        public DateTime To = CurrentMinute.AddMinutes(1);
 
        [Page(12, "Scope", 100)]
        [Header(13, "Object:")]
        [ToolTip(14, "Return events related to this object. Use asterisks (*) as wildcard characters.")]
        public string Object = string.Empty;
 
        [Page(12, "Scope", 100)]
        [Header(15, "Actor:")]
        [ToolTip(16, "Return events related to this actor. Use asterisks (*) as wildcard characters.")]
        public string Actor = string.Empty;
 
        [Page(12, "Scope", 100)]
        [Header(17, "Event ID:")]
        [ToolTip(18, "Return events with this Event ID. Use asterisks (*) as wildcard characters.")]
        public string EventId = string.Empty;
 
        [Page(12, "Scope", 100)]
        [Header(19, "Module:")]
        [ToolTip(20, "Return events related to this module. Use asterisks (*) as wildcard characters.")]
        public string Module = string.Empty;
 
        [Page(12, "Scope", 100)]
        [Header(21, "Facility:")]
        [ToolTip(22, "Return events related to this facility. Use asterisks (*) as wildcard characters.")]
        public string Facility = string.Empty;
 
        [Page(23, "Types", 110)]
        [Header(24, "Debug")]
        [ToolTip(25, "Check this box to include debug messages in the result.")]
        public bool Debug = true;
 
        [Page(23, "Types", 110)]
        [Header(26, "Information")]
        [ToolTip(27, "Check this box to include information messages in the result.")]
        public bool Informational = true;
 
        [Page(23, "Types", 110)]
        [Header(28, "Notice")]
        [ToolTip(29, "Check this box to include notification messages in the result.")]
        public bool Notice = true;
 
        [Page(23, "Types", 110)]
        [Header(30, "Warning")]
        [ToolTip(31, "Check this box to include warning messages in the result.")]
        public bool Warning = true;
 
        [Page(23, "Types", 110)]
        [Header(32, "Error")]
        [ToolTip(33, "Check this box to include error messages in the result.")]
        public bool Error = true;
 
        [Page(23, "Types", 110)]
        [Header(34, "Critical")]
        [ToolTip(35, "Check this box to include critical messages in the result.")]
        public bool Critical = true;
 
        [Page(23, "Types", 110)]
        [Header(36, "Alert")]
        [ToolTip(37, "Check this box to include alert messages in the result.")]
        public bool Alert = true;
 
        [Page(23, "Types", 110)]
        [Header(38, "Emergency")]
        [ToolTip(39, "Check this box to include emergency messages in the result.")]
        public bool Emergency = true;
 
        [Page(40, "Levels", 120)]
        [Header(41, "Minor")]
        [ToolTip(42, "Check this box to include minor events in the result.")]
        public bool Minor = true;
 
        [Page(40, "Levels", 120)]
        [Header(43, "Medium")]
        [ToolTip(44, "Check this box to include medium events in the result.")]
        public bool Medium = true;
 
        [Page(40, "Levels", 120)]
        [Header(45, "Major")]
        [ToolTip(46, "Check this box to include major events in the result.")]
        public bool Major = true;
 
        public static DateTime CurrentMinute
        {
            get
            {
                DateTime TP = DateTime.Now;
                return new DateTime(TP.Year, TP.Month, TP.Day, TP.Hour, TP.Minute, 0);
            }
        }
 
        public override Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(SearchEventsCommand), 1, "Search...");
        }
 
        public override ICommand Copy()
        {
            return new SearchEventsCommand((SearchEventLogNode)this.Report)
            {
                Offset = this.Offset,
                MaxCount = this.MaxCount,
                From = this.From,
                To = this.To,
                Object = this.Object,
                Actor = this.Actor,
                EventId = this.EventId,
                Module = this.Module,
                Facility = this.Facility,
                Debug = this.Debug,
                Informational = this.Informational,
                Notice = this.Notice,
                Warning = this.Warning,
                Error = this.Error,
                Critical = this.Critical,
                Alert = this.Alert,
                Emergency = this.Emergency,
                Minor = this.Minor,
                Medium = this.Medium,
                Major = this.Major
            };
        }
 
        public override Task StartQueryExecutionAsync(Query Query, Language Language)
        {
            this.DoSearch(Query, Language);
            return Task.CompletedTask;
        }
 
        private async void DoSearch(Query Query, Language Language)
        {
            try
            {
                await Query.Start();
                await Query.SetTitle(await Language.GetStringAsync(typeof(SearchEventsCommand), 47, "Events"));
 
                if (this.To < this.From)
                {
                    DateTime Temp = this.To;
                    this.To = this.From;
                    this.From = Temp;
                }
 
                ChunkedList<Filter> Filters = new ChunkedList<Filter>()
                {
                    new FilterFieldGreaterOrEqualTo("Timestamp", this.From),
                    new FilterFieldLesserOrEqualTo("Timestamp", this.To)
                };
 
                WebServices.SearchEvents.AddFilter(Filters, "Object", this.Object);
                WebServices.SearchEvents.AddFilter(Filters, "Actor", this.Actor);
                WebServices.SearchEvents.AddFilter(Filters, "EventId", this.EventId);
                WebServices.SearchEvents.AddFilter(Filters, "Module", this.Module);
                WebServices.SearchEvents.AddFilter(Filters, "Facility", this.Facility);
 
                if (!(this.Debug && this.Informational && this.Notice && this.Warning && this.Error && this.Critical && this.Alert && this.Emergency))
                {
                    List<Filter> Ors = new List<Filter>();
 
                    WebServices.SearchEvents.AddFilter(Ors, "Type", this.Debug, EventType.Debug);
                    WebServices.SearchEvents.AddFilter(Ors, "Type", this.Informational, EventType.Informational);
                    WebServices.SearchEvents.AddFilter(Ors, "Type", this.Notice, EventType.Notice);
                    WebServices.SearchEvents.AddFilter(Ors, "Type", this.Warning, EventType.Warning);
                    WebServices.SearchEvents.AddFilter(Ors, "Type", this.Error, EventType.Error);
                    WebServices.SearchEvents.AddFilter(Ors, "Type", this.Critical, EventType.Critical);
                    WebServices.SearchEvents.AddFilter(Ors, "Type", this.Alert, EventType.Alert);
                    WebServices.SearchEvents.AddFilter(Ors, "Type", this.Emergency, EventType.Emergency);
 
                    Filters.Add(new FilterOr(Ors.ToArray()));
                }
 
                if (!(this.Minor && this.Medium && this.Major))
                {
                    List<Filter> Ors = new List<Filter>();
 
                    WebServices.SearchEvents.AddFilter(Ors, "Level", this.Minor, EventLevel.Minor);
                    WebServices.SearchEvents.AddFilter(Ors, "Level", this.Medium, EventLevel.Medium);
                    WebServices.SearchEvents.AddFilter(Ors, "Level", this.Major, EventLevel.Major);
 
                    Filters.Add(new FilterOr(Ors.ToArray()));
                }
 
                await Query.SetStatus(await Language.GetStringAsync(typeof(SearchEventsCommand), 48, "Searching database..."));
                await Query.BeginSection(await Language.GetStringAsync(typeof(SearchEventsCommand), 49, "Search Result"));
                await Query.NewTable("Events", await Language.GetStringAsync(typeof(SearchEventsCommand), 47, "Events"),
                    new Column("Timestamp", await Language.GetStringAsync(typeof(SearchEventsCommand), 50, "Timestamp"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("Type", await Language.GetStringAsync(typeof(SearchEventsCommand), 51, "Type"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("Level", await Language.GetStringAsync(typeof(SearchEventsCommand), 52, "Level"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("Object", await Language.GetStringAsync(typeof(SearchEventsCommand), 53, "Object"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("Actor", await Language.GetStringAsync(typeof(SearchEventsCommand), 54, "Actor"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("EventId", await Language.GetStringAsync(typeof(SearchEventsCommand), 55, "EventId"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("Module", await Language.GetStringAsync(typeof(SearchEventsCommand), 56, "Module"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("Facility", await Language.GetStringAsync(typeof(SearchEventsCommand), 57, "Facility"),
                        null, null, null, null, ColumnAlignment.Left, null),
                    new Column("Message", await Language.GetStringAsync(typeof(SearchEventsCommand), 58, "Message"),
                        null, null, null, null, ColumnAlignment.Left, null));
 
                foreach (PersistedEvent Event in await Database.Find<PersistedEvent>(this.Offset, this.MaxCount + 1, new FilterAnd(Filters.ToArray()), "-Timestamp"))
                {
                    if (this.MaxCount-- <= 0)
                        break;
 
                    StringBuilder sb = new StringBuilder(Event.Message);
 
                    if (!(Event.Tags is null) && Event.Tags.Length > 0)
                    {
                        sb.AppendLine();
 
                        foreach (PersistedTag Tag in Event.Tags)
                        {
                            sb.AppendLine();
                            sb.Append(Tag.Name);
                            sb.Append('=');
                            sb.Append(Tag.Value?.ToString());
                        }
                    }
 
                    if (!string.IsNullOrEmpty(Event.StackTrace))
                    {
                        sb.AppendLine();
                        sb.AppendLine();
                        sb.AppendLine(Event.StackTrace);
                    }
 
                    await Query.NewRecords("Events",
                        new Record(Event.Timestamp, Event.Type.ToString(), Event.Level.ToString(), Event.Object, Event.Actor,
                            Event.EventId, Event.Module, Event.Facility, sb.ToString()));
                }
 
                await Query.TableDone("Events");
                await Query.EndSection();
            }
            catch (Exception ex)
            {
                await Query.LogMessage(ex);
            }
            finally
            {
                await Query.Done();
            }
        }
 
    }
}