AuthorizeAccessToContract.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.Runtime.Threading;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Contracts;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Legal
{
    public class AuthorizeAccessToContract : AgentPostResource
    {
        public AuthorizeAccessToContract()
            : base("Legal/AuthorizeAccessToContract",
                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(AuthorizeAccessToContract).Namespace + ".JSON.AuthorizeAccessToContract.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(AuthorizeAccessToContract).Namespace + ".XML.AuthorizeAccessToContract.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
 
            CaseInsensitiveString ContractId = (string)Parameters["PContractId"].AssociatedObjectValue;
            if (CaseInsensitiveString.IsNullOrEmpty(ContractId))
                throw new BadRequestException("No Contract ID specified.");
 
            XmppAddress ContractIdAddress = new XmppAddress(ContractId);
            if (!ContractIdAddress.IsBareJID)
                throw new BadRequestException("Invalid Contract ID.");
 
            if (!(XmppServerModule.Legal is null) && !XmppServerModule.Legal.IsComponentDomain(ContractIdAddress.Domain, true))
                throw new BadRequestException("Not a local Contract ID.");
 
            CaseInsensitiveString RemoteId = (string)Parameters["PRemoteId"].AssociatedObjectValue;
            bool Authorized = (bool)Parameters["PAuthorized"].AssociatedObjectValue;
 
            if (CaseInsensitiveString.IsNullOrEmpty(RemoteId))
                throw new BadRequestException("No Remote ID specified.");
 
            XmppAddress RemoteAddress = new XmppAddress(RemoteId);
            if (!RemoteAddress.IsBareJID)
                throw new BadRequestException("Invalid Remote ID.");
 
            if (!(XmppServerModule.Legal is null))
            {
                using (Semaphore Semaphore = await Semaphores.BeginRead("iotsc:" + ContractId.LowerCase))
                {
                    Contract Contract = await XmppServerModule.Legal.GetContract(ContractId)
                    ?? throw new NotFoundException("Contract not found.");
 
                    XmppAddress From = new XmppAddress(User.UserName + "@" + Gateway.Domain);
 
                    if (!await Contract.CanRead(From, XmppServerModule.Server, XmppServerModule.Legal))
                        throw new ForbiddenException("You do not have access rights to contract.");
 
                    LegalComponent.ClientInformation ClientInfo = await XmppServerModule.Legal.GetNetworkIdentity(RemoteId, true, true, Contract.Version);
                    CaseInsensitiveString RemoteJid = ClientInfo.Jid;
                    XmppServerModule.Legal.ContractAuthorization(RemoteJid, From.BareJid, ContractId, Authorized);
                }
            }
 
            await Response.Return(new NamedDictionary<string, object>("AckResponse", AgentNamespace));
        }
    }
}