GeoClient.cs

using System;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.XMPP.Events;
using Waher.Runtime.Geo;
 
namespace Waher.Networking.XMPP.Geo
{
    public class GeoClient : XmppExtension
    {
        private readonly string componentAddress;
 
        public const string NamespaceGeoSpatialNeuroFoundationV1 = "urn:nf:iot:geo:1.0";
 
        public static readonly string[] NamespacesGeoSpatial = new string[]
        {
            NamespaceGeoSpatialNeuroFoundationV1
        };
 
        public static bool IsNamespaceGeoSpatial(string Namespace)
        {
            return Array.IndexOf(NamespacesGeoSpatial, Namespace) >= 0;
        }
 
        #region Construction
 
        public GeoClient(XmppClient Client, string ComponentAddress)
            : base(Client)
        {
            this.componentAddress = ComponentAddress;
 
            #region NeuroFoundation V1
 
            this.client.RegisterMessageHandler("added", NamespaceGeoSpatialNeuroFoundationV1, this.AddedMessageHandler, true);
            this.client.RegisterMessageHandler("updated", NamespaceGeoSpatialNeuroFoundationV1, this.UpdatedMessageHandler, false);
            this.client.RegisterMessageHandler("removed", NamespaceGeoSpatialNeuroFoundationV1, this.RemovedMessageHandler, false);
 
            #endregion
        }
 
        public override void Dispose()
        {
            #region NeuroFoundation V1
 
            this.client.UnregisterMessageHandler("added", NamespaceGeoSpatialNeuroFoundationV1, this.AddedMessageHandler, true);
            this.client.UnregisterMessageHandler("updated", NamespaceGeoSpatialNeuroFoundationV1, this.UpdatedMessageHandler, false);
            this.client.UnregisterMessageHandler("removed", NamespaceGeoSpatialNeuroFoundationV1, this.RemovedMessageHandler, false);
 
            #endregion
 
            base.Dispose();
        }
 
        public override string[] Extensions => new string[] { };
 
        public string ComponentAddress => this.componentAddress;
 
        #endregion
 
        #region Subscribe
 
        public Task Subscribe(GeoPosition Min, GeoPosition Max,
            EventHandlerAsync<SubscribedEventArgs> Callback, object State)
        {
            return this.Subscribe(string.Empty, Min, Max, null, Callback, State);
        }
 
        public Task Subscribe(GeoPosition Min, GeoPosition Max, int Ttl,
            EventHandlerAsync<SubscribedEventArgs> Callback, object State)
        {
            return this.Subscribe(string.Empty, Min, Max, Ttl, Callback, State);
        }
 
        public Task Subscribe(string SubscriptionId, GeoPosition Min, GeoPosition Max, int? Ttl,
            EventHandlerAsync<SubscribedEventArgs> Callback, object State)
        {
            return this.Subscribe(this.componentAddress, SubscriptionId, Min, Max, Ttl, Callback, State);
        }
 
        public async Task Subscribe(string ComponentAddress, string SubscriptionId,
            GeoPosition Min, GeoPosition Max, int? Ttl,
            EventHandlerAsync<SubscribedEventArgs> Callback, object State)
        {
            if (Min is null)
                throw new ArgumentNullException(nameof(Min));
 
            if (Max is null)
                throw new ArgumentNullException(nameof(Max));
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<subscribe xmlns='");
            Xml.Append(NamespaceGeoSpatialNeuroFoundationV1);
 
            if (!string.IsNullOrEmpty(SubscriptionId))
            {
                Xml.Append("' id='");
                Xml.Append(XML.Encode(SubscriptionId));
            }
 
            Xml.Append("' minLat='");
            Xml.Append(CommonTypes.Encode(Min.Latitude));
 
            Xml.Append("' minLon='");
            Xml.Append(CommonTypes.Encode(Min.Longitude));
 
            if (Min.Altitude.HasValue)
            {
                Xml.Append("' minAlt='");
                Xml.Append(CommonTypes.Encode(Min.Altitude.Value));
            }
 
            Xml.Append("' maxLat='");
            Xml.Append(CommonTypes.Encode(Max.Latitude));
 
            Xml.Append("' maxLon='");
            Xml.Append(CommonTypes.Encode(Max.Longitude));
 
            if (Max.Altitude.HasValue)
            {
                Xml.Append("' maxAlt='");
                Xml.Append(CommonTypes.Encode(Max.Altitude.Value));
            }
 
            if (Ttl.HasValue)
            {
                Xml.Append("' ttl='");
                Xml.Append(Ttl.Value);
            }
 
            Xml.Append("'/>");
 
            await this.client.SendIqSet(ComponentAddress, Xml.ToString(), async (sender, e) =>
            {
                await Callback.Raise(this, new SubscribedEventArgs(e));
            }, State);
        }
 
        public Task<SubscribedEventArgs> SubscribeAsync(GeoPosition Min, GeoPosition Max)
        {
            return this.SubscribeAsync(string.Empty, Min, Max, null);
        }
 
        public Task<SubscribedEventArgs> SubscribeAsync(GeoPosition Min, GeoPosition Max, int Ttl)
        {
            return this.SubscribeAsync(string.Empty, Min, Max, Ttl);
        }
 
        public Task<SubscribedEventArgs> SubscribeAsync(string SubscriptionId, GeoPosition Min, GeoPosition Max, int? Ttl)
        {
            return this.SubscribeAsync(this.componentAddress, SubscriptionId, Min, Max, Ttl);
        }
 
        public async Task<SubscribedEventArgs> SubscribeAsync(string ComponentAddress, string SubscriptionId,
            GeoPosition Min, GeoPosition Max, int? Ttl)
        {
            TaskCompletionSource<SubscribedEventArgs> Result = new TaskCompletionSource<SubscribedEventArgs>();
 
            await this.Subscribe(ComponentAddress, SubscriptionId, Min, Max, Ttl, (sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to perform subscription."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region Unsubscribe
 
        public Task Unsubscribe(string SubscriptionId,
            EventHandlerAsync<UnsubscribedEventArgs> Callback, object State)
        {
            return this.Unsubscribe(this.componentAddress, SubscriptionId, Callback, State);
        }
 
        public async Task Unsubscribe(string ComponentAddress, string SubscriptionId,
            EventHandlerAsync<UnsubscribedEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<unsubscribe xmlns='");
            Xml.Append(NamespaceGeoSpatialNeuroFoundationV1);
            Xml.Append("' id='");
            Xml.Append(XML.Encode(SubscriptionId));
            Xml.Append("'/>");
 
            await this.client.SendIqSet(ComponentAddress, Xml.ToString(), async (sender, e) =>
            {
                await Callback.Raise(this, new UnsubscribedEventArgs(e));
            }, State);
        }
 
        public Task<UnsubscribedEventArgs> UnsubscribeAsync(string SubscriptionId)
        {
            return this.UnsubscribeAsync(this.componentAddress, SubscriptionId);
        }
 
        public async Task<UnsubscribedEventArgs> UnsubscribeAsync(string ComponentAddress, string SubscriptionId)
        {
            TaskCompletionSource<UnsubscribedEventArgs> Result = new TaskCompletionSource<UnsubscribedEventArgs>();
 
            await this.Unsubscribe(ComponentAddress, SubscriptionId, (sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to perform unsubscription."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region Event Notifications
 
        private async Task AddedMessageHandler(object Sender, MessageEventArgs e)
        {
            string SubscriptionId = XML.Attribute(e.Content, "id");
            GeoObjectReference Ref = ParseObjectReferenceFirstChild(e.Content);
 
            if (!(Ref is null))
                await this.ObjectAdded.Raise(this, new GeoObjectSubscriptionEventArgs(e, SubscriptionId, Ref));
        }
 
        public event EventHandlerAsync<GeoObjectSubscriptionEventArgs> ObjectAdded;
 
        private async Task UpdatedMessageHandler(object Sender, MessageEventArgs e)
        {
            string SubscriptionId = XML.Attribute(e.Content, "id");
            GeoObjectReference Ref = ParseObjectReferenceFirstChild(e.Content);
 
            if (!(Ref is null))
                await this.ObjectUpdated.Raise(this, new GeoObjectSubscriptionEventArgs(e, SubscriptionId, Ref));
        }
 
        public event EventHandlerAsync<GeoObjectSubscriptionEventArgs> ObjectUpdated;
 
        private async Task RemovedMessageHandler(object Sender, MessageEventArgs e)
        {
            string SubscriptionId = XML.Attribute(e.Content, "id");
            GeoObjectReference Ref = ParseObjectReferenceFirstChild(e.Content);
 
            if (!(Ref is null))
                await this.ObjectRemoved.Raise(this, new GeoObjectSubscriptionEventArgs(e, SubscriptionId, Ref));
        }
 
        public event EventHandlerAsync<GeoObjectSubscriptionEventArgs> ObjectRemoved;
 
        private static GeoObjectReference ParseObjectReferenceFirstChild(XmlElement ParentXml)
        {
            if (ParentXml is null)
                return null;
 
            foreach (XmlNode Node in ParentXml.ChildNodes)
            {
                if (Node is XmlElement E &&
                    E.LocalName == "ref" &&
                    IsNamespaceGeoSpatial(E.NamespaceURI))
                {
                    return ParseObjectReference(E);
                }
            }
 
            return null;
        }
 
        private static GeoObjectReference ParseObjectReference(XmlElement Xml)
        {
            GeoObjectReference Result = new GeoObjectReference()
            {
                GeoId = XML.Attribute(Xml, "id"),
                Creator = Xml.HasAttribute("creator") ? XML.Attribute(Xml, "creator") : null,
                Position = new GeoPosition(
                    XML.Attribute(Xml, "lat", 0.0),
                    XML.Attribute(Xml, "lon", 0.0),
                    Xml.HasAttribute("alt") ? XML.Attribute(Xml, "alt", 0.0) : (double?)null),
                TimeToLive = Xml.HasAttribute("ttl") ? XML.Attribute(Xml, "ttl", 0) : (int?)null,
                Created = XML.Attribute(Xml, "created", DateTime.MinValue),
                Updated = Xml.HasAttribute("updated") ? XML.Attribute(Xml, "updated", DateTime.MinValue) : (DateTime?)null,
                From = Xml.HasAttribute("from") ? XML.Attribute(Xml, "from", DateTime.MinValue) : (DateTime?)null,
                To = Xml.HasAttribute("to") ? XML.Attribute(Xml, "to", DateTime.MinValue) : (DateTime?)null
            };
 
            foreach (XmlNode N in Xml.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    Result.Definition = E;
                    break;
                }
            }
 
            return Result;
        }
 
        #endregion
 
        #region publish
 
        public Task Publish(string GeoId, GeoPosition Location, int? Ttl,
            DateTime? From, DateTime? To, string CustomXml)
        {
            return Task.CompletedTask;  // TODO
        }
 
        public Task PublishAsync()
        {
            return Task.CompletedTask;  // TODO
        }
 
        #endregion
 
        #region Delete
 
        public Task Delete()
        {
            return Task.CompletedTask;  // TODO
        }
 
        public Task DeleteAsync()
        {
            return Task.CompletedTask;  // TODO
        }
 
        #endregion
 
        #region Search
 
        public Task Search()
        {
            return Task.CompletedTask;  // TODO
        }
 
        public Task SearchAsync()
        {
            return Task.CompletedTask;  // TODO
        }
 
        #endregion
    }
}