ProposeTemplate.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Markdown;
using Waher.Content.Xml;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Runtime.Counters;
using Waher.Runtime.IO;
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.Identity;
using Waher.Service.IoTBroker.Setup;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Legal
{
    public class ProposeTemplate : AgentPostResource
    {
        public ProposeTemplate()
            : base("Legal/ProposeTemplate",
                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(ProposeTemplate).Namespace + ".JSON.ProposeTemplate.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(ProposeTemplate).Namespace + ".XML.ProposeTemplate.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
 
            string TemplateBase64 = (string)Parameters["PTemplateBase64"].AssociatedObjectValue;
            byte[] TemplateBin;
            string TemplateXmlString;
            XmlDocument TemplateXml;
            ParsedContract Parsed;
            Contract Template;
 
            try
            {
                TemplateBin = Convert.FromBase64String(TemplateBase64);
            }
            catch (Exception)
            {
                throw new BadRequestException("Invalid BASE64-encoding of template.");
            }
 
            try
            {
                TemplateXmlString = Strings.GetString(TemplateBin, Encoding.UTF8);
                
                TemplateXml = XML.ParseXml(TemplateXmlString, true);
            }
            catch (Exception ex)
            {
                throw new BadRequestException("Invalid template XML, or encoding of template XML: " + ex.Message);
            }
 
            try
            {
                Parsed = await Contract.Parse(TemplateXml.DocumentElement, XmppServerModule.Legal);
            }
            catch (Exception ex)
            {
                throw new BadRequestException("Unable to parse contract XML: " + ex.Message);
            }
 
            Template = Parsed.Contract 
                ?? throw new BadRequestException("Unable to parse contract XML.");
 
            if (Parsed.HasStatus)
                throw new BadRequestException("Status element not permitted when creating new contract.");
 
            if (!CaseInsensitiveString.IsNullOrEmpty(Template.ContractId))
                throw new BadRequestException("id attribute must not be set by client.");
 
            if (!(Template.ClientSignatures is null) && Template.ClientSignatures.Length > 0)
                throw new BadRequestException("Predefined signatures not permitted.");
            
            if (!(Template.ServerSignature is null))
                throw new BadRequestException("Server signature cannot be provided by client.");
 
            if (Template.PartsMode == ContractParts.ExplicitlyDefined && (Template.Parts is null || Template.Parts.Length == 0))
                throw new BadRequestException("No explicit parts defined.");
 
            if (Template.PartsMode != ContractParts.TemplateOnly)
                throw new BadRequestException("Contract is not a template.");
 
            if (Template.Duration <= Duration.Zero)
                throw new BadRequestException("Contract duration must be positive.");
 
            CaseInsensitiveString LegalDomain;
 
            if (XmppServerModule.Legal is null)
                LegalDomain = "legal.example.com";
            else
            {
                string Errors = await XmppServerModule.Legal?.CheckContentIntegrity(Template);
                if (!string.IsNullOrEmpty(Errors))
                    throw new BadRequestException(Errors);
 
                LegalIdentity Identity = await XmppServerModule.Legal.GetCurrentApprovedLegalIdentityAsync(User.UserName)
                    ?? throw new ForbiddenException(Request, "No current approved legal identity found for account.");
 
                Errors = await XmppServerModule.Legal.ValidateContent(Template, null);
                if (!string.IsNullOrEmpty(Errors))
                    throw new BadRequestException(Errors);
 
                LegalDomain = Identity.Provider;
            }
 
            Template.State = ContractState.Proposed;
            Template.Provider = LegalDomain;
            Template.Account = User.UserName;
            Template.Created = LegalComponent.UtcNowSecond;
            Template.Updated = DateTime.MinValue;
 
            await Database.Insert(Template);
 
            Template.ContractId = Template.ObjectId + "@" + Template.Provider;
            await Template.Sign(XmppServerModule.Legal);
 
            await Database.Update(Template);
 
            if (Template.CanActAsTemplate)
                await RuntimeCounters.IncrementCounter("Legal.Template." + Template.State.ToString());
            else
                await RuntimeCounters.IncrementCounter("Legal.Contract." + Template.State.ToString());
 
            KeyValuePair<string, object>[] Tags = Template.GetTags();
            string FromJid = User.UserName + "@" + Request.Host;
 
            Log.Notice("Contract proposal registered.",
                Template.ContractId.Value, FromJid, "ContractRegistered", Tags);
 
            if (BrokerNotificationConfiguration.Instance?.ContractProposalReceived ?? false)
            {
                StringBuilder Markdown = new StringBuilder();
 
                Markdown.Append("Contract proposal received: [");
                Markdown.Append(MarkdownDocument.Encode(Template.ContractId));
                Markdown.Append("](");
                Markdown.Append(Gateway.GetUrl("/Contract.md?ID=" + Template.ContractId));
                Markdown.AppendLine(")");
                Markdown.AppendLine();
                LegalComponent.Output(Markdown, Tags);
 
                await Gateway.SendNotification(Markdown.ToString());
            }
 
            XmppServerModule.Legal?.ContractAuthorization(FromJid, FromJid, Template.ContractId, true);
 
            if (!(XmppServerModule.Legal is null))
                await XmppServerModule.Legal.SendContractUpdatedEvent(Template, true);
 
            StringBuilder Xml = new StringBuilder();
            await Template.Serialize(Xml, true, true, true, true, true, true, true, null, XmppServerModule.Legal);
            TemplateXmlString = Xml.ToString();
 
            TemplateXml = XML.ParseXml(TemplateXmlString, true);
 
            await Response.Return(new NamedDictionary<string, object>("TemplateResponse", AgentNamespace)
            {
                { "Template", TemplateXml },
            });
        }
 
    }
}