LegalIdentityGetter.cs

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.Contracts.EventArguments;
using Waher.Runtime.Inventory;
using Waher.Runtime.Temporary;
 
namespace Waher.Service.IoTBroker.Getters
{
    public class LegalIdentityGetter : IContentGetter, IDisposable
    {
        private static string defaultPurpose = string.Empty;
 
        private readonly Dictionary<string, TaskCompletionSource<LegalIdentityPetitionResponseEventArgs>> identityPetitions = new Dictionary<string, TaskCompletionSource<LegalIdentityPetitionResponseEventArgs>>();
        private readonly object syncObj = new object();
        private bool handlerAdded = false;
 
        public LegalIdentityGetter()
        {
        }
 
        public static string DefaultPurpose
        {
            get => defaultPurpose;
            set
            {
                if (string.IsNullOrEmpty(value))
                    throw new ArgumentException("Default purpose cannot be empty.", nameof(DefaultPurpose));
 
                defaultPurpose = value;
            }
        }
 
        public string[] UriSchemes => new string[] { "iotid" };
 
        public bool CanGet(Uri Uri, out Grade Grade)
        {
            if (string.Compare(Uri.Scheme, "iotid", true) == 0)
            {
                Grade = Grade.Ok;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public void Dispose()
        {
            lock (this.syncObj)
            {
                if (this.handlerAdded)
                {
                    Gateway.ContractsClient.PetitionedIdentityResponseReceived -= this.Client_PetitionedIdentityResponseReceived;
                    this.handlerAdded = false;
                }
            }
        }
 
        public Task<ContentResponse> GetAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, 
            params KeyValuePair<string, string>[] Headers)
        {
            return this.GetAsync(Uri, Certificate, RemoteCertificateValidator, InternetContent.DefaultTimeout, Headers);
        }
 
        public async Task<ContentResponse> GetAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, 
            int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            ContractsClient Client = Gateway.ContractsClient;
            if (Client is null)
                return new ContentResponse(new NotSupportedException("Contracts feature not supported or activated on this system."));
 
            lock (this.syncObj)
            {
                if (!this.handlerAdded)
                {
                    Client.PetitionedIdentityResponseReceived += this.Client_PetitionedIdentityResponseReceived;
                    this.handlerAdded = true;
                }
            }
 
            string LegalId = Uri.AbsolutePath;
 
            try
            {
                LegalIdentity Identity = await Client.GetLegalIdentityAsync(LegalId);
                return new ContentResponse(string.Empty, Identity, Array.Empty<byte>());
            }
            catch (Exception)
            {
                TaskCompletionSource<LegalIdentityPetitionResponseEventArgs> Result = new TaskCompletionSource<LegalIdentityPetitionResponseEventArgs>();
                string PetitionId = Guid.NewGuid().ToString();
                string Purpose = null;
 
                if (!string.IsNullOrEmpty(Uri.Query))
                {
                    NameValueCollection Parameters = HttpUtility.ParseQueryString(Uri.Query);
 
                    foreach (string Parameter in Parameters.AllKeys)
                    {
                        switch (Parameter.ToLower())
                        {
                            case "p":
                            case "purpose":
                                Purpose = Parameters[Parameter];
                                break;
                        }
                    }
                }
 
                if (string.IsNullOrEmpty(Purpose))
                    Purpose = "Processing referenced identity.";
 
                lock (this.syncObj)
                {
                    this.identityPetitions[PetitionId] = Result;
                }
 
                try
                {
                    await Client.PetitionIdentityAsync(LegalId, PetitionId, Purpose);
 
                    Task _ = Task.Delay(TimeoutMs).ContinueWith((T) =>
                    {
                        Result.TrySetException(new TimeoutException("Response to petition not received within allotted time."));
                        return Task.CompletedTask;
                    });
                }
                catch (Exception ex)
                {
                    lock (this.syncObj)
                    {
                        this.identityPetitions.Remove(PetitionId);
                    }
 
                    return new ContentResponse(ex);
                }
 
                LegalIdentityPetitionResponseEventArgs e = await Result.Task;
 
                return new ContentResponse(string.Empty, e.RequestedIdentity, Array.Empty<byte>());
            }
        }
 
        private Task Client_PetitionedIdentityResponseReceived(object Sender, LegalIdentityPetitionResponseEventArgs e)
        {
            lock (this.syncObj)
            {
                if (this.identityPetitions.TryGetValue(e.PetitionId, out TaskCompletionSource<LegalIdentityPetitionResponseEventArgs> Result))
                    Result.TrySetResult(e);
            }
 
            return Task.CompletedTask;
        }
 
        public Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, InternetContent.DefaultTimeout, Headers);
        }
 
        public Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, TemporaryStream Destination, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, InternetContent.DefaultTimeout, Destination, Headers);
        }
 
        public Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, TimeoutMs, null, Headers);
        }
 
        public async Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, TemporaryStream Destination,
            params KeyValuePair<string, string>[] Headers)
        {
            ContentResponse Content = await this.GetAsync(Uri, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
            if (Content.HasError)
                return new ContentStreamResponse(Content.Error);
 
            LegalIdentity Identity = (LegalIdentity)Content.Decoded;
            StringBuilder Xml = new StringBuilder();
            Identity.Serialize(Xml, true, true, true, true, true, true, true);
            byte[] Bin = Encoding.UTF8.GetBytes(Xml.ToString());
            bool DestinationCreated = false;
 
            if (Destination is null)
            {
                Destination = new TemporaryStream();
                DestinationCreated = true;
            }
 
            try
            {
                await Destination.WriteAsync(Bin, 0, Bin.Length);
            }
            catch (Exception ex)
            {
                if (DestinationCreated)
                    Destination.Dispose();
 
                return new ContentStreamResponse(ex);
            }
 
            return new ContentStreamResponse("application/xml; charset=utf-8", Destination);
        }
    }
}