ValidateContract.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Html;
using Waher.Content.Xml;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.Contracts.EventArguments;
using Waher.Networking.XMPP.Contracts.HumanReadable;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class ValidateContract : HttpSynchronousResource, IHttpPostMethod
    {
        public ValidateContract()
            : base("/ValidateContract")
        {
        }
 
        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.Contract");
 
            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("ContractId", out object Obj) || !(Obj is string ContractId) ||
                !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 (ContractId.IndexOf('@') < 0)
            {
                await Response.SendResponse(new BadRequestException("Invalid contract 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
            {
                Contract Contract = await Gateway.ContractsClient.GetContractAsync(ContractId);
                ResponseObj = await this.Encode(Contract);
            }
            catch (Exception)
            {
                string PetitionId = Guid.NewGuid().ToString();
 
                Purpose = Purpose.Trim();
                if (string.IsNullOrEmpty(Purpose))
                    Purpose = "Validating Contract through web interface at " + Gateway.Domain;
                
                if (!await Gateway.PetitionContract(ContractId, PetitionId, Purpose, Password, async (_, e) =>
                {
                    await ClientEvents.PushEvent(new string[] { TabID }, "PetitionResponseReceived", JSON.Encode(new Dictionary<string, object>()
                    {
                        { "PetitionId", e.PetitionId },
                        { "PetitionResponse", e.Response },
                        { "Contract", await this.Encode(e.RequestedContract) },
                        { "Declined", e.RequestedContract 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", ContractId },
                    { "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(Contract Contract)
        {
            if (Contract is null)
                return null;
 
            ContractValidationEventArgs e = await Gateway.ContractsClient.ValidateAsync(Contract);
            ContractStatus Status = e.Status;
            List<Dictionary<string, object>> List = new List<Dictionary<string, object>>();
            Dictionary<string, object> ResponseObj = new Dictionary<string, object>()
                {
                    { "ContractId", Contract.ContractId },
                    { "ContractIdUri", Contract.ContractIdUriString },
                    { "Petition", false },
                    { "Provider", Contract.Provider },
                    { "State", Contract.State.ToString() },
                    { "ValidationStatus", Status.ToString() },
                    { "ValidationStatusTags", e.Tags },
                    { "Visibility", Contract.Visibility },
                    { "Created", Contract.Created },
                    { "Updated", Contract.Updated },
                    { "From", Contract.From },
                    { "To", Contract.To },
                    { "SignAfter", Contract.SignAfter },
                    { "SignBefore", Contract.SignBefore },
                    { "Duration", Contract.Duration.ToString() },
                    { "ArchiveOptional", Contract.ArchiveOptional.ToString() },
                    { "ArchiveRequired", Contract.ArchiveRequired.ToString() },
                    { "TemplateId", Contract.TemplateId },
                    { "TemplateIdUri", Contract.TemplateIdUriString },
                    { "CanActAsTemplate", Contract.CanActAsTemplate },
                    { "PartsMode", Contract.PartsMode.ToString() },
                    { "DefaultLanguage", Contract.DefaultLanguage },
                    { "ForHumans", await this.Encode(Contract.ForHumans, Contract) },
                    { "ContentSchemaDigest", Contract.ContentSchemaDigest is null ? null : Convert.ToBase64String(Contract.ContentSchemaDigest) },
                    { "ContentSchemaHashFunction", Contract.ContentSchemaHashFunction.ToString() },
                    { "ForMachinesLocalName", Contract.ForMachinesLocalName },
                    { "ForMachinesNamespace", Contract.ForMachinesNamespace },
                    { "ForMachines", XML.PrettyXml(Contract.ForMachines) }
                };
 
            if (!(Contract.Roles is null))
            {
                foreach (Role Role in Contract.Roles)
                {
                    List.Add(new Dictionary<string, object>()
                    {
                        { "Name", Role.Name },
                        { "MinCount", Role.MinCount },
                        { "MaxCount", Role.MaxCount },
                        { "CanRevoke", Role.CanRevoke },
                        { "Descriptions", await this.Encode(Role.Descriptions, Contract) }
                    });
                }
 
                ResponseObj["Roles"] = List.ToArray();
                List.Clear();
            }
 
            if (!(Contract.Parts is null))
            {
                foreach (Part Part in Contract.Parts)
                {
                    List.Add(new Dictionary<string, object>()
                    {
                        { "LegalId", Part.LegalId },
                        { "LegalIdUri", Part.LegalIdUriString },
                        { "Role", Part.Role }
                    });
                }
 
                ResponseObj["Parts"] = List.ToArray();
                List.Clear();
            }
 
            if (!(Contract.Parameters is null))
            {
                foreach (Parameter Parameter in Contract.Parameters)
                {
                    List.Add(new Dictionary<string, object>()
                    {
                        { "Name", Parameter.Name },
                        { "Value", Parameter.ObjectValue },
                        { "Descriptions", await this .Encode(Parameter.Descriptions, Contract) }
                    });
                }
 
                ResponseObj["Parameters"] = List.ToArray();
                List.Clear();
            }
 
            if (!(Contract.ClientSignatures is null))
            {
                foreach (ClientSignature ClientSignature in Contract.ClientSignatures)
                {
                    List.Add(new Dictionary<string, object>()
                    {
                        { "BareJid", ClientSignature.BareJid },
                        { "DigitalSignature", Convert.ToBase64String(ClientSignature.DigitalSignature) },
                        { "LegalId", ClientSignature.LegalId },
                        { "LegalIdUri", ClientSignature.LegalIdUriString },
                        { "Role", ClientSignature.Role },
                        { "Timestamp", ClientSignature.Timestamp },
                        { "Transferable", ClientSignature.Transferable }
                    });
                }
 
                ResponseObj["ClientSignatures"] = List.ToArray();
                List.Clear();
            }
 
            if (!(Contract.Attachments is null))
            {
                foreach (ClientSignature ClientSignature in Contract.ClientSignatures)
                {
                    List.Add(new Dictionary<string, object>()
                    {
                        { "BareJid", ClientSignature.BareJid },
                        { "DigitalSignature", Convert.ToBase64String(ClientSignature.DigitalSignature) },
                        { "LegalId", ClientSignature.LegalId },
                        { "LegalIdUri", ClientSignature.LegalIdUriString },
                        { "Role", ClientSignature.Role },
                        { "Timestamp", ClientSignature.Timestamp },
                        { "Transferable", ClientSignature.Transferable }
                    });
                }
 
                ResponseObj["ClientSignatures"] = List.ToArray();
                List.Clear();
            }
 
            if (!(Contract.Attachments is null))
            {
                foreach (Attachment Attachment in Contract.Attachments)
                {
                    List.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"] = List.ToArray();
                List.Clear();
            }
 
            ResponseObj["ServerSignature"] = new Dictionary<string, object>()
            {
                { "DigitalSignature", Convert.ToBase64String(Contract.ServerSignature.DigitalSignature) },
                { "Timestamp", Contract.ServerSignature.Timestamp }
            };
 
            return ResponseObj;
        }
 
        private async Task<Dictionary<string, object>[]> Encode(HumanReadableText[] Text, Contract Contract)
        {
            List<Dictionary<string, object>> List = new List<Dictionary<string, object>>();
 
            foreach (HumanReadableText Localization in Text)
            {
                List.Add(new Dictionary<string, object>()
                {
                    { "Language", Localization.Language },
                    { "IsWellDefined", await Localization.IsWellDefined() },
                    { "Html", HtmlDocument.GetBody(await Localization.GenerateHTML(Contract)) }
                });
            }
 
            return List.ToArray();
        }
 
    }
}