SearchEvents.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Events.Persistence;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Collections;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class SearchEvents : HttpSynchronousResource, IHttpPostMethod
    {
        public SearchEvents()
            : base("/SearchEvents")
        {
        }
 
        public override bool HandlesSubPaths => false;
        public override bool UserSessions => true;
        public bool AllowsPOST => true;
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            Gateway.AssertUserAuthenticated(Request, "Admin.Data.Events");
 
            if (!Request.HasData)
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            ContentResponse Content = await Request.DecodeDataAsync();
            if (Content.HasError || !(Content.Decoded is Dictionary<string, object> Form))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Form.TryGetValue("offset", out object Obj) || !(Obj is int Offset) ||
                !Form.TryGetValue("maxCount", out Obj) || !(Obj is int MaxCount) ||
                !Form.TryGetValue("from", out Obj) || !(Obj is string FromStr) || !XML.TryParse(FromStr, out DateTime From) ||
                !Form.TryGetValue("to", out Obj) || !(Obj is string ToStr) || !XML.TryParse(ToStr, out DateTime To) ||
                !Form.TryGetValue("object", out Obj) || !(Obj is string Object) ||
                !Form.TryGetValue("actor", out Obj) || !(Obj is string Actor) ||
                !Form.TryGetValue("eventId", out Obj) || !(Obj is string EventId) ||
                !Form.TryGetValue("module", out Obj) || !(Obj is string Module) ||
                !Form.TryGetValue("facility", out Obj) || !(Obj is string Facility) ||
                !Form.TryGetValue("debug", out Obj) || !(Obj is bool Debug) ||
                !Form.TryGetValue("informational", out Obj) || !(Obj is bool Informational) ||
                !Form.TryGetValue("notice", out Obj) || !(Obj is bool Notice) ||
                !Form.TryGetValue("warning", out Obj) || !(Obj is bool Warning) ||
                !Form.TryGetValue("error", out Obj) || !(Obj is bool Error) ||
                !Form.TryGetValue("critical", out Obj) || !(Obj is bool Critical) ||
                !Form.TryGetValue("alert", out Obj) || !(Obj is bool Alert) ||
                !Form.TryGetValue("emergency", out Obj) || !(Obj is bool Emergency) ||
                !Form.TryGetValue("minor", out Obj) || !(Obj is bool Minor) ||
                !Form.TryGetValue("medium", out Obj) || !(Obj is bool Medium) ||
                !Form.TryGetValue("major", out Obj) || !(Obj is bool Major))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (To < From)
            {
                DateTime Temp = To;
                To = From;
                From = Temp;
            }
 
            if (Offset == 0)
            {
                ChunkedList<KeyValuePair<string, object>> Tags = new ChunkedList<KeyValuePair<string, object>>()
                    {
                        new KeyValuePair<string, object>("From", From.ToString()),
                        new KeyValuePair<string, object>("To", To.ToString()),
                    };
 
                if (!string.IsNullOrEmpty(Object))
                    Tags.Add(new KeyValuePair<string, object>("Object", Object));
 
                if (!string.IsNullOrEmpty(Actor))
                    Tags.Add(new KeyValuePair<string, object>("Actor", Actor));
 
                if (!string.IsNullOrEmpty(EventId))
                    Tags.Add(new KeyValuePair<string, object>("EventId", EventId));
 
                if (!string.IsNullOrEmpty(Module))
                    Tags.Add(new KeyValuePair<string, object>("Module", Module));
 
                if (!string.IsNullOrEmpty(Facility))
                    Tags.Add(new KeyValuePair<string, object>("Facility", Facility));
 
                if (!(Debug && Informational && Notice && Warning && Error && Critical && Alert && Emergency))
                {
                    if (Debug)
                        Tags.Add(new KeyValuePair<string, object>("Debug", Debug));
 
                    if (Informational)
                        Tags.Add(new KeyValuePair<string, object>("Informational", Informational));
 
                    if (Notice)
                        Tags.Add(new KeyValuePair<string, object>("Notice", Notice));
 
                    if (Warning)
                        Tags.Add(new KeyValuePair<string, object>("Warning", Warning));
 
                    if (Error)
                        Tags.Add(new KeyValuePair<string, object>("Error", Error));
 
                    if (Critical)
                        Tags.Add(new KeyValuePair<string, object>("Critical", Critical));
 
                    if (Alert)
                        Tags.Add(new KeyValuePair<string, object>("Alert", Alert));
 
                    if (Emergency)
                        Tags.Add(new KeyValuePair<string, object>("Emergency", Emergency));
                }
 
                if (!(Minor && Medium && Major))
                {
                    if (Minor)
                        Tags.Add(new KeyValuePair<string, object>("Minor", Minor));
 
                    if (Medium)
                        Tags.Add(new KeyValuePair<string, object>("Medium", Medium));
 
                    if (Major)
                        Tags.Add(new KeyValuePair<string, object>("Major", Major));
                }
 
                Log.Informational("Searching event log.",
                    string.Empty,
                    Request.RemoteEndPoint,
                    Tags.ToArray());
            }
 
            ChunkedList<Filter> Filters = new ChunkedList<Filter>()
            {
                new FilterFieldGreaterOrEqualTo("Timestamp", From),
                new FilterFieldLesserOrEqualTo("Timestamp", To)
            };
 
            AddFilter(Filters, "Object", Object);
            AddFilter(Filters, "Actor", Actor);
            AddFilter(Filters, "EventId", EventId);
            AddFilter(Filters, "Module", Module);
            AddFilter(Filters, "Facility", Facility);
 
            if (!(Debug && Informational && Notice && Warning && Error && Critical && Alert && Emergency))
            {
                List<Filter> Ors = new List<Filter>();
 
                AddFilter(Ors, "Type", Debug, EventType.Debug);
                AddFilter(Ors, "Type", Informational, EventType.Informational);
                AddFilter(Ors, "Type", Notice, EventType.Notice);
                AddFilter(Ors, "Type", Warning, EventType.Warning);
                AddFilter(Ors, "Type", Error, EventType.Error);
                AddFilter(Ors, "Type", Critical, EventType.Critical);
                AddFilter(Ors, "Type", Alert, EventType.Alert);
                AddFilter(Ors, "Type", Emergency, EventType.Emergency);
 
                Filters.Add(new FilterOr(Ors.ToArray()));
            }
 
            if (!(Minor && Medium && Major))
            {
                List<Filter> Ors = new List<Filter>();
 
                AddFilter(Ors, "Level", Minor, EventLevel.Minor);
                AddFilter(Ors, "Level", Medium, EventLevel.Medium);
                AddFilter(Ors, "Level", Major, EventLevel.Major);
 
                Filters.Add(new FilterOr(Ors.ToArray()));
            }
 
            bool More = false;
            ChunkedList<Dictionary<string, object>> Events = new ChunkedList<Dictionary<string, object>>();
            IEnumerable<PersistedEvent> RecordSet = await Database.Find<PersistedEvent>(
                Offset, MaxCount + 1, new FilterAnd(Filters.ToArray()), "-Timestamp");
 
            foreach (PersistedEvent Event in RecordSet)
            {
                if (MaxCount-- > 0)
                {
                    Events.Add(new Dictionary<string, object>()
                    {
                        { "timestamp", Event.Timestamp },
                        { "type", Event.Type },
                        { "level", Event.Level },
                        { "message", Event.Message },
                        { "object", Event.Object },
                        { "actor", Event.Actor },
                        { "eventId", Event.EventId },
                        { "module", Event.Module },
                        { "facility", Event.Facility },
                        { "stackTrace", Event.StackTrace },
                        { "tags", TagsToJson(Event.Tags) }
                    });
                }
                else
                {
                    More = true;
                    break;
                }
            }
 
            Dictionary<string, object> Result = new Dictionary<string, object>()
            {
                { "more" , More },
                { "events", Events.ToArray() }
            };
 
            await Response.Return(Result);
        }
 
        public static void AddFilter(ChunkedList<Filter> Filters, string ParameterName, string Value)
        {
            if (!string.IsNullOrEmpty(Value))
            {
                if (Value.IndexOf('*') >= 0)
                    Filters.Add(new FilterFieldLikeRegEx(ParameterName, CommonTypes.RegexStringEncode(Value.Replace("*", "__WILDCARD__")).Replace("__WILDCARD__", ".*")));
                else
                    Filters.Add(new FilterFieldEqualTo(ParameterName, Value));
            }
        }
 
        public static void AddFilter(List<Filter> Filters, string ParameterName, bool Value, Enum EnumValue)
        {
            if (Value)
                Filters.Add(new FilterFieldEqualTo(ParameterName, EnumValue));
        }
 
        private static Dictionary<string, object>[] TagsToJson(PersistedTag[] Tags)
        {
            if (Tags is null)
                return null;
 
            int i, c = Tags.Length;
            Dictionary<string, object>[] Result = new Dictionary<string, object>[c];
 
            for (i = 0; i < c; i++)
            {
                Result[i] = new Dictionary<string, object>()
                {
                    { "name", Tags[i].Name },
                    { "value", Tags[i].Value }
                };
            }
 
            return Result;
        }
 
    }
}