GetContractTokens.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Filters;
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 GetContractTokens : AgentPostResource
    {
        public GetContractTokens()
            : base("Tokens/GetContractTokens",
                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(GetContractTokens).Namespace + ".JSON.GetContractTokens.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(GetContractTokens).Namespace + ".XML.GetContractTokens.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
 
            CaseInsensitiveString ContractId = (string)Parameters["PContractId"].AssociatedObjectValue;
            int Offset = 0;
            int MaxCount = int.MaxValue;
            bool References = true;
 
            if (Parameters.TryGetValue("POffset", out IElement E) && !(E is null) &&
                E.AssociatedObjectValue is double d)
            {
                Offset = (int)d;
            }
 
            if (Parameters.TryGetValue("PMaxCount", out E) && !(E is null) &&
                E.AssociatedObjectValue is double d2)
            {
                MaxCount = (int)d2;
            }
 
            if (Parameters.TryGetValue("PReferences", out E) && !(E is null) &&
                E.AssociatedObjectValue is bool b)
            {
                References = b;
            }
 
            XmppAddress ContractAddr = new XmppAddress(ContractId);
            if (!XmppServerModule.Legal.IsComponentDomain(ContractAddr.Domain, true))
                throw new BadRequestException("Contract not hosted on this server.");
 
            Contract Contract = await XmppServerModule.Legal.GetContract(ContractId)
                ?? throw new NotFoundException("Contract not found.");
 
            string BareJid = User.UserName + "@" + Gateway.Domain;
            
            if (!await Contract.CanRead(new XmppAddress(BareJid), XmppServerModule.Server, XmppServerModule.Legal))
                throw new ForbiddenException("Access to contract denied.");
 
            string Xml;
            IEnumerable<Token> Tokens = await Database.Find<Token>(Offset, MaxCount,
                new FilterFieldEqualTo("CreationContract", ContractId), "-Created");
 
            if (References)
            {
                List<TokenReference> TokenReferences = new List<TokenReference>();
 
                foreach (Token Token in Tokens)
                {
                    TokenReferences.Add(new TokenReference()
                    {
                        TokenId = Token.TokenId
                    });
                }
 
                Xml = NeuroFeaturesProcessor.SerializeTokenReferences(TokenReferences);
            }
            else
                Xml = NeuroFeaturesProcessor.SerializeTokenReferences(Tokens);
 
            XmlDocument Doc = new XmlDocument()
            {
                PreserveWhitespace = true
            };
            Doc.LoadXml(Xml);
 
            await Response.Return(new NamedDictionary<string, object>("TokensResult", AgentNamespace)
            {
                { "Tokens", Doc }
            });
        }
    }
}