ValidateLegalId.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.Contracts.EventArguments;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class ValidateLegalId : HttpSynchronousResource, IHttpPostMethod
    {
        public ValidateLegalId()
            : base("/ValidateLegalId")
        {
        }
 
        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.Legal.Validate.ID");
 
            if (!Request.HasData)
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            ContentResponse Content = await Request.DecodeDataAsync();
            if (Content.HasError || !(Content.Decoded is Dictionary<string, object> RequestObj) ||
                !RequestObj.TryGetValue("LegalId", out object Obj) || !(Obj is string LegalId) ||
                !RequestObj.TryGetValue("Purpose", out Obj) || !(Obj is string Purpose) ||
                !RequestObj.TryGetValue("Password", out Obj) || !(Obj is string Password) ||
                !RequestObj.TryGetValue("TabID", out Obj) || !(Obj is string TabID))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (LegalId.IndexOf('@') < 0)
            {
                await Response.SendResponse(new BadRequestException("Invalid legal identity."));
                return;
            }
 
            if (Gateway.ContractsClient is null)
            {
                await Response.SendResponse(new ServiceUnavailableException("Broker not connected to a legal service."));
                return;
            }
 
            Dictionary<string, object> ResponseObj;
 
            try
            {
                LegalIdentity Identity = await Gateway.ContractsClient.GetLegalIdentityAsync(LegalId);
                ResponseObj = await this.Encode(Identity);
            }
            catch (Exception)
            {
                string PetitionId = Guid.NewGuid().ToString();
 
                Purpose = Purpose.Trim();
                if (string.IsNullOrEmpty(Purpose))
                    Purpose = "Validating Legal Identity through web interface at " + Gateway.Domain;
 
                if (!await Gateway.PetitionLegalIdentity(LegalId, PetitionId, Purpose, Password, async (_, e) =>
                {
                    await ClientEvents.PushEvent(new string[] { TabID }, "PetitionResponseReceived", JSON.Encode(new Dictionary<string, object>()
                    {
                        { "PetitionId", e.PetitionId },
                        { "PetitionResponse", e.Response },
                        { "Identity", await this.Encode(e.RequestedIdentity) },
                        { "Declined", e.RequestedIdentity is null && !(e.Message is null) },
                        { "Timeout", e.Message is null }
                    }, false), true);
                }, TimeSpan.FromMinutes(5)))
                {
                    await Response.SendResponse(new ForbiddenException(Request, "Unable to sign petition. Either password is incorrect, or no legal identity assigned to broker."));
                    return;
                }
 
                ResponseObj = new Dictionary<string, object>()
                {
                    { "Id", LegalId },
                    { "Petition", true },
                    { "PetitionId", PetitionId },
                    { "Message", "The information has been petitioned from the owner. If the owner accepts to share the information, it will be displayed here when it arrives." }
                };
            }
 
            await Response.Return(ResponseObj);
        }
 
        private async Task<Dictionary<string, object>> Encode(LegalIdentity Identity)
        {
            if (Identity is null)
                return null;
 
            IdentityValidationEventArgs e = await Gateway.ContractsClient.ValidateAsync(Identity);
            IdentityStatus Status = e.Status;
            Dictionary<string, object> Properties = new Dictionary<string, object>();
            Dictionary<string, object> ResponseObj = new Dictionary<string, object>()
                {
                    { "Id", Identity.Id },
                    { "IdUri", Identity.IdUriString },
                    { "Petition", false },
                    { "ClientKeyName", Identity.ClientKeyName },
                    { "ClientPubKey", Identity.HasClientPublicKey ? Convert.ToBase64String(Identity.ClientPubKey) : null },
                    { "ClientSignature", Identity.HasClientSignature ? Convert.ToBase64String(Identity.ClientSignature) : null },
                    { "Created", Identity.Created },
                    { "From", Identity.From },
                    { "To", Identity.To },
                    { "HasClientPublicKey", Identity.HasClientPublicKey },
                    { "HasClientSignature", Identity.HasClientSignature },
                    { "Provider", Identity.Provider },
                    { "ServerSignature", Convert.ToBase64String(Identity.ServerSignature) },
                    { "State", Identity.State.ToString() },
                    { "Updated", Identity.Updated },
                    { "ValidationStatus", Status.ToString() },
                    { "ValidationStatusTags", e.Tags },
                    { "Properties", Properties }
                };
 
            foreach (Property P in Identity.Properties)
                Properties[P.Name] = P.Value;
 
            if (!(Identity.Attachments is null))
            {
                List<Dictionary<string, object>> Attachments = new List<Dictionary<string, object>>();
 
                foreach (Attachment Attachment in Identity.Attachments)
                {
                    Attachments.Add(new Dictionary<string, object>()
                    {
                        { "Id", Attachment.Id },
                        { "ContentType", Attachment.ContentType },
                        { "FileName", Attachment.FileName },
                        { "Url", Attachment.Url },
                        { "Signature", Convert.ToBase64String(Attachment.Signature) },
                        { "Timestamp", Attachment.Timestamp },
                    });
                }
 
                ResponseObj["Attachments"] = Attachments.ToArray();
            }
 
            return ResponseObj;
        }
 
    }
}