GetToken.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Server;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.Legal.Contracts;
using Waher.Service.IoTBroker.NeuroFeatures;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Tokens
{
    public class GetToken : AgentPostResource
    {
        public GetToken()
            : base("Tokens/GetToken",
                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(GetToken).Namespace + ".JSON.GetToken.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(GetToken).Namespace + ".XML.GetToken.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
            string TokenId = (string)Parameters["PTokenId"].AssociatedObjectValue;
            string BareJid = User.UserName + "@" + Gateway.Domain;
 
            Token Token = await NeuroFeaturesProcessor.GetToken(TokenId, false)
                ?? throw new NotFoundException("Token not found.");
 
            await AssertAuthorization(Token, new XmppAddress(BareJid));
 
            StringBuilder Xml = new StringBuilder();
            Token.Serialize(Xml, true, true);
            
            XmlDocument Doc = new XmlDocument()
            {
                PreserveWhitespace = true
            };
            Doc.LoadXml(Xml.ToString());
 
            await Response.Return(new NamedDictionary<string, object>("TokenResult", AgentNamespace)
            {
                { "Token", Doc }
            });
        }
 
        internal static async Task AssertAuthorization(Token Token, XmppAddress From)
        {
            switch (Token.Visibility)
            {
                case ContractVisibility.Public:
                case ContractVisibility.PublicSearchable:
                    return;
 
                case ContractVisibility.DomainAndParts:
                    if (XmppServerModule.Server.IsServerDomain(From.Domain, true))
                        return;
                    break;
            }
 
            if (Token.OwnerJid == From.BareJid)
                return;
 
            if (Token.IsExternalPart(From.BareJid))
                return;
 
            Contract Contract = await XmppServerModule.Legal.GetContract(Token.OwnershipContract)
                ?? throw new ServiceUnavailableException("Ownership contract of token not accessible at this time.");
 
            if (!await Contract.CanRead(From, XmppServerModule.Server, XmppServerModule.Legal))
                throw new ForbiddenException("You do not have access to this token.");
        }
    }
}