ValidateSenderContractSignature.cs

using System.Threading.Tasks;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Service.IoTBroker.EDaler.Uris;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Contracts;
 
namespace Waher.Service.IoTBroker.EDaler.Transactions
{
    public class ValidateSenderContractSignature : EDalerTransaction
    {
        private readonly LegalComponent legal;
        private readonly IEDalerContractualPaymentUri contractualPaymentUri;
        private Contract contract = null;
        private readonly TaskCompletionSource<Contract> contractWaiter = new TaskCompletionSource<Contract>();
        private bool prepareCompleted = false;
 
        public ValidateSenderContractSignature(IEDalerContractualPaymentUri Uri, LegalComponent Legal)
            : base((EDalerUri)Uri)
        {
            this.legal = Legal;
            this.contractualPaymentUri = Uri;
        }
 
        internal async Task<Contract> GetContractAsync()
        {
            if (this.prepareCompleted)
                return this.contract;
            else
                return await this.contractWaiter.Task;
        }
 
        protected override async Task<bool> DoPrepare()
        {
            try
            {
                CaseInsensitiveString ContractId = this.contractualPaymentUri.ContractWithSignatures;
                if (CaseInsensitiveString.IsNullOrEmpty(ContractId))
                    return false;
 
                this.contract = await this.legal.GetContract(ContractId);
                if (!await ValidateContractSigned.CheckContractValid(this.contract, this.Uri, ContractId, XmppServerModule.Legal))
                    return false;
 
                bool SenderFound = false;
 
                foreach (ClientSignature Signature in this.contract.ClientSignatures)
                {
                    switch (this.Uri.FromType)
                    {
                        case EntityType.LegalId:
                            if (Signature.LegalId == this.Uri.From.Address)
                                SenderFound = true;
                            break;
 
                        case EntityType.NetworkJid:
                            if (Signature.BareJid == this.Uri.From.Address)
                                SenderFound = true;
                            break;
                    }
 
                    if (SenderFound)
                        break;
                }
 
                if (!SenderFound)
                {
                    this.Uri.State.Error(Uris.States.EDalerUriErrorType.BadRequest, "Sender not part in the contract.", false);
                    return false;
                }
 
                XmppAddress Addr = new XmppAddress(this.contract.ContractId);
                if (!await this.legal.ValidateServerSignature(Addr.Domain, this.Uri.PreSign, this.Uri.Signature))
                {
                    this.Uri.State.Error(Uris.States.EDalerUriErrorType.Forbidden, "Invalid server signature.", false);
                    return false;
                }
 
                return true;
            }
            finally
            {
                this.prepareCompleted = true;
                this.contractWaiter.TrySetResult(this.contract);
            }
        }
 
        protected override Task<bool> DoExecute()
        {
            return Task.FromResult(true);     // No need to do nothing.
        }
 
        protected override Task<bool> DoCommit()
        {
            return Task.FromResult(true);     // No need to do nothing.
        }
 
        protected override Task<bool> DoRollback()
        {
            return Task.FromResult(true);     // No need to do nothing.
        }
    }
}