AddXmlNote.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.Legal.Contracts;
using Waher.Service.IoTBroker.NeuroFeatures;
using Waher.Service.IoTBroker.NeuroFeatures.Events;
using Waher.Service.IoTBroker.StateMachines;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Tokens
{
    public class AddXmlNote : AgentPostResource
    {
        public AddXmlNote()
            : base("Tokens/AddXmlNote",
                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(AddXmlNote).Namespace + ".JSON.AddXmlNote.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(AddXmlNote).Namespace + ".XML.AddXmlNote.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
            string TokenId = (string)Parameters["PTokenId"].AssociatedObjectValue;
            bool Personal = (bool)Parameters["PPersonal"].AssociatedObjectValue;
            string BareJid = User.UserName + "@" + Gateway.Domain;
 
            object Obj = Parameters["PNote"].AssociatedObjectValue;
            string LocalName;
            string Namespace;
            XmlDocument Doc;
 
            if (Obj is string Xml)
            {
                if (!XML.IsValidXml(Xml))
                    throw new BadRequestException("Invalid XML note.");
 
                Doc = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
 
                Doc.LoadXml(Xml);
 
                (string, Dictionary<string, ValidationSchema>) P = await XmppServerModule.Legal.ValidateContent(Doc);
                if (!string.IsNullOrEmpty(P.Item1))
                    throw new BadRequestException(P.Item1);
 
                LocalName = Doc.DocumentElement.LocalName;
                Namespace = Doc.DocumentElement.NamespaceURI;
            }
            else if (Obj is XmlDocument Doc2)
            {
                Xml = Doc2.DocumentElement.OuterXml;
                LocalName = Doc2.DocumentElement.LocalName;
                Namespace = Doc2.DocumentElement.NamespaceURI;
 
                (string, Dictionary<string, ValidationSchema>) P = await XmppServerModule.Legal.ValidateContent(Doc2);
                if (!string.IsNullOrEmpty(P.Item1))
                    throw new BadRequestException(P.Item1);
            }
            else if (Obj is XmlElement E)
            {
                Xml = E.OuterXml;
                LocalName = E.LocalName;
                Namespace = E.NamespaceURI;
 
                Doc = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
                Doc.LoadXml(Xml);
 
                (string, Dictionary<string, ValidationSchema>) P = await XmppServerModule.Legal.ValidateContent(Doc);
                if (!string.IsNullOrEmpty(P.Item1))
                    throw new BadRequestException("XML Note invalid: " + P.Item1);
            }
            else
                throw new BadRequestException("Invalid XML note.");
 
            Token Token = await NeuroFeaturesProcessor.GetToken(TokenId, true)
                ?? throw new NotFoundException("Token not found.");
 
            TokenNoteEvent Event;
 
            if (Token.OwnerJid == BareJid)
            {
                Event = new NoteXml()
                {
                    ArchiveOptional = Token.ArchiveOptional,
                    ArchiveRequired = Token.ArchiveRequired,
                    Expires = Token.Expires,
                    Personal = Personal,
                    Timestamp = DateTime.UtcNow,
                    TokenId = Token.TokenId,
                    Note = Xml,
                    LocalName = LocalName,
                    Namespace = Namespace
                };
            }
            else
            {
                await AddTextNote.AssertApprovedExternalSource(Token, BareJid);
 
                Event = new ExternalNoteXml()
                {
                    ArchiveOptional = Token.ArchiveOptional,
                    ArchiveRequired = Token.ArchiveRequired,
                    Expires = Token.Expires,
                    Personal = Personal,
                    Timestamp = DateTime.UtcNow,
                    TokenId = Token.TokenId,
                    Note = Xml,
                    LocalName = LocalName,
                    Namespace = Namespace,
                    Source = BareJid
                };
            }
 
            await Database.Insert(Event);
            await StateMachineProcessor.EventGenerated(Token, Event);
 
            StringBuilder sb = new StringBuilder();
            Event.Serialize(sb);
 
            Doc = new XmlDocument()
            {
                PreserveWhitespace = true
            };
            Doc.LoadXml(Xml.ToString());
 
            await Response.Return(new NamedDictionary<string, object>("NoteResult", AgentNamespace)
            {
                { "Note", Doc }
            });
        }
    }
}