CheckEndpoint.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Security.LoginMonitor;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Intelligence
{
    public class CheckEndpoint : AgentPostResource
    {
        public CheckEndpoint()
            : base("Intelligence/CheckEndpoint",
                new KeyValuePair<Type, Expression>(typeof(Dictionary<string, object>), new Expression(jsonPattern)),
                new KeyValuePair<Type, Expression>(typeof(XmlDocument), new Expression(xmlPattern)))
        {
        }
 
        public static LoginAuditor TestAuditor { get; set; }
 
        private static readonly string jsonPattern = Resources.LoadResourceAsText(typeof(CheckEndpoint).Namespace + ".JSON.CheckEndpoint.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(CheckEndpoint).Namespace + ".XML.CheckEndpoint.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AssertUserAuthenticated(Request);
 
            LoginAuditor Auditor = Gateway.LoginAuditor ?? TestAuditor
                ?? throw new ServiceUnavailableException("Login Auditor not enabled.");
 
            string Endpoint = (string)Parameters["PEndpoint"].AssociatedObjectValue;
            RemoteEndpoint RemoteEndpoint = await Auditor.GetAnnotatedStateObject(Endpoint);
            NamedDictionary<string, object> Result = new NamedDictionary<string, object>("Endpoint", AgentNamespace)
            {
                { "endpoint", RemoteEndpoint?.Endpoint ?? Endpoint }
            };
 
            if (!(RemoteEndpoint is null))
            {
                bool AddMetaInfo = false;
                NamedDictionary<string, object> EndpointInfo = new NamedDictionary<string, object>("EndpointInfo", AgentNamespace)
                {
                    { "created", RemoteEndpoint.Created },
                    { "lastProtocol", RemoteEndpoint.LastProtocol },
                    { "lastFailed", RemoteEndpoint.LastFailed },
                    { "domain", RemoteEndpoint.Domain?.Value ?? string.Empty }
                };
                Result["EndpointInfo"] = EndpointInfo;
 
                if (RemoteEndpoint.Blocked)
                {
                    EndpointInfo["permanentBlock"] = true;
                    AddMetaInfo = true;
                }
                else if (RemoteEndpoint.LastFailed)
                {
                    DateTime? Next = Auditor.GetEarliestLoginOpportunity(RemoteEndpoint.State, RemoteEndpoint.Timestamps);
 
                    if (Next.HasValue)
                    {
                        if (Next.Value == DateTime.MaxValue)
                            EndpointInfo["permanentBlock"] = true;
                        else
                            EndpointInfo["temporaryBlock"] = Next.Value;
 
                        AddMetaInfo = true;
                    }
                }
 
                if (AddMetaInfo)
                {
                    EndpointInfo["reason"] = RemoteEndpoint.Reason;
                    EndpointInfo["whois"] = RemoteEndpoint.WhoIs;
                    EndpointInfo["city"] = RemoteEndpoint.City;
                    EndpointInfo["region"] = RemoteEndpoint.Region;
                    EndpointInfo["country"] = RemoteEndpoint.Country;
                    EndpointInfo["countryCode"] = RemoteEndpoint.Code;
                    EndpointInfo["flag"] = RemoteEndpoint.Flag;
                }
            }
 
            await Response.Return(Result);
        }
    }
}