GetContract.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Html;
using Waher.Content.Markdown;
using Waher.Content.Markdown.Contracts;
using Waher.Content.Markdown.Wpf;
using Waher.Content.Markdown.Xamarin;
using Waher.Content.Xml;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP;
using Waher.Runtime.Inventory;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Contracts;
using Waher.Service.IoTBroker.Legal.HumanReadable;
using Waher.Service.IoTBroker.NeuroFeatures;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Legal
{
    public class GetContract : AgentPostResource
    {
        public GetContract()
            : base("Legal/GetContract",
                new KeyValuePair<Type, Expression>(typeof(Dictionary<string, object>), new Expression(jsonPattern)),
                new KeyValuePair<Type, Expression>(typeof(XmlDocument), new Expression(xmlPattern)))
        {
        }
 
        private static readonly string jsonPattern = Resources.LoadResourceAsText(typeof(GetContract).Namespace + ".JSON.GetContract.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(GetContract).Namespace + ".XML.GetContract.req");
 
        public override bool Synchronous => false;
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
            string ContractId = (string)Parameters["PContractId"].AssociatedObjectValue;
            string FormatStr = (string)Parameters["PFormat"]?.AssociatedObjectValue;
            int i = ContractId.IndexOf('@');
            if (i < 0)
                throw new BadRequestException("Invalid Contract ID.");
 
            ReportFormat? Format = null;
 
            if (!string.IsNullOrEmpty(FormatStr))
            {
                if (Enum.TryParse(FormatStr, out ReportFormat F))
                    Format = F;
                else
                    throw new BadRequestException("Unsupported report format: " + FormatStr);
            }
 
            string LegalDomain = ContractId.Substring(i + 1);
 
            if (XmppServerModule.Server is null)
            {
                XmppClient Client = Gateway.XmppClient;
 
                if (Client is null)
                {
                    if (Types.TryGetModuleParameter("XMPP", out object Obj) && Obj is XmppClient Client2)
                        Client = Client2;
                }
 
                if (Client is null)
                    throw new ServiceUnavailableException("XMPP Client not available.");
 
                await Client.SendIqGet(LegalDomain, "<getContract id=\"" + XML.Encode(ContractId) + "\" xmlns=\"" +
                    LegalComponent.NamespaceSmartContracts(NamespaceSet.Current) + "\"/>", async (Sender, e) =>
                    {
                        XmlElement E;
 
                        if (e.Ok && !((E = e.FirstElement) is null) && E.LocalName == "contract")
                        {
                            if (Format.HasValue)
                            {
                                ParsedContract ParsedContract = await Contract.Parse(E, XmppServerModule.Legal);
                                if (!(ParsedContract.Contract is null))
                                    E = await FormatHumanReadableText(E, Format.Value, ParsedContract.Contract);
                            }
 
                            await Response.Return(new NamedDictionary<string, object>("ContractResponse", AgentNamespace)
                            {
                                { "Contract", E }
                            });
                        }
                        else
                            await Response.SendResponse(ToHttpException(e.StanzaError) ?? new ServiceUnavailableException("Unable to get contract."));
 
                    }, null);
            }
            else
            {
                await XmppServerModule.Server.SendIqRequest("get",
                    User.UserName + "@" + (Gateway.Domain?.Value ?? string.Empty),
                    LegalDomain, string.Empty, "<getContract id=\"" + XML.Encode(ContractId) + "\" xmlns=\"" +
                    LegalComponent.NamespaceSmartContracts(NamespaceSet.Current) + "\"/>", async (Sender, e) =>
                    {
                        XmlElement E;
 
                        if (e.Ok && !((E = e.FirstElement) is null) && E.LocalName == "contract")
                        {
                            if (Format.HasValue)
                            {
                                ParsedContract ParsedContract = await Contract.Parse(E, XmppServerModule.Legal);
                                if (!(ParsedContract.Contract is null))
                                    E = await FormatHumanReadableText(E, Format.Value, ParsedContract.Contract);
                            }
 
                            await Response.Return(new NamedDictionary<string, object>("ContractResponse", AgentNamespace)
                            {
                                { "Contract", E }
                            });
                        }
                        else
                            await Response.SendResponse(ToHttpException(XmppClient.GetExceptionObject(e.ErrorElement)) ?? new ServiceUnavailableException("Unable to get contract."));
 
                    }, null);
            }
        }
 
        private static async Task<XmlElement> FormatHumanReadableText(XmlElement E, ReportFormat Format, Contract Contract)
        {
            XmlElement E2;
 
            if (E.LocalName == "description" || 
                E.LocalName == "humanReadableText" ||
                E.LocalName == "label")
            {
                HumanReadableText Text = HumanReadableText.Parse(E);
 
                if (!(Text is null))
                {
                    MarkdownOutput MarkdownOutput = new MarkdownOutput();
                    Text.ToMarkdown(MarkdownOutput, Contract, 2, 0);
 
                    string Markdown = MarkdownOutput.ToString();
                    MarkdownDocument Doc = await MarkdownDocument.CreateAsync(Markdown);
 
                    E2 = E.OwnerDocument.CreateElement(E.Prefix, E.LocalName + Format.ToString(), E.NamespaceURI);
 
                    if (!string.IsNullOrEmpty(Text.Language))
                        E2.SetAttribute("xml:lang", Text.Language);
 
                    switch (Format)
                    {
                        case ReportFormat.Markdown:
                            E2.InnerText = await Doc.GenerateMarkdown(true);
                            break;
 
                        case ReportFormat.Html:
                            E2.InnerText = HtmlDocument.GetBody(await Doc.GenerateHTML());
                            break;
 
                        case ReportFormat.Text:
                            E2.InnerText = await Doc.GeneratePlainText();
                            break;
 
                        case ReportFormat.Xaml:
                            E2.InnerText = await Doc.GenerateXAML();
                            break;
 
                        case ReportFormat.XamarinXaml:
                            E2.InnerText = await Doc.GenerateXamarinForms();
                            break;
 
                        case ReportFormat.SmartContract:
                            E2.InnerText = await Doc.GenerateSmartContractXml();
                            break;
                    }
                }
                else
                    E2 = E;
            }
            else
            {
                E2 = E.OwnerDocument.CreateElement(E.Prefix, E.LocalName, E.NamespaceURI);
 
                foreach (XmlAttribute Attr in E.Attributes)
                    E2.SetAttribute(Attr.Name, Attr.NamespaceURI, Attr.Value);
 
                foreach (XmlNode N in E.ChildNodes)
                {
                    if (N is XmlElement E3)
                        E2.AppendChild(await FormatHumanReadableText(E3, Format, Contract));
                }
            }
 
            return E2;
        }
 
    }
}