ValidateContractSigned.cs

using System.Collections.Generic;
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 ValidateContractSigned : EDalerTransaction
    {
        private readonly LegalComponent legal;
        private readonly ValidateSenderContractSignature senderValidation;
 
        public ValidateContractSigned(EDalerUri Uri, LegalComponent Legal)
            : this(Uri, Legal, null)
        {
        }
 
        public ValidateContractSigned(EDalerUri Uri, LegalComponent Legal, ValidateSenderContractSignature SenderValidation)
            : base(Uri)
        {
            this.legal = Legal;
            this.senderValidation = SenderValidation;
        }
 
        protected override async Task<bool> DoPrepare()
        {
            if (CaseInsensitiveString.IsNullOrEmpty(this.Uri.ContractCondition))
                return true;
 
            Contract Contract;
 
            if (!(this.senderValidation is null) &&
                this.Uri is IEDalerContractualPaymentUri ContractualPaymentUri &&
                ContractualPaymentUri.ContractWithSignatures == this.Uri.ContractCondition)
            {
                Contract = await this.senderValidation.GetContractAsync();  // Avoid getting same contract twice.
            }
            else
            {
                KeyValuePair<Contract,IqResultEventArgs> P = await this.legal.GetContract(this.Uri.ContractCondition);
                Contract = P.Key;
            }
 
            return await CheckContractValid(Contract, this.Uri, this.Uri.ContractCondition, XmppServerModule.Legal);
        }
 
        internal static async Task<bool> CheckContractValid(Contract Contract, EDalerUri Uri, string ContractId, LegalComponent Legal)
        {
            if (Contract is null)
            {
                Uri.State.Error(Uris.States.EDalerUriErrorType.BadRequest, "Conditional contract not found: " + ContractId, false);
                return false;
            }
 
            // TODO: Double check contract signature & state
 
            switch (Contract.State)
            {
                case ContractState.Approved:
                    Uri.State.Error(Uris.States.EDalerUriErrorType.Conflict, "Conditional contract is approved, but not signed.", true);
                    return false;
 
                case ContractState.BeingSigned:
                    Uri.State.Error(Uris.States.EDalerUriErrorType.Conflict, "Conditional contract is being signed, but not all parties have signed yet.", true);
                    return false;
 
                case ContractState.Deleted:
                    Uri.State.Error(Uris.States.EDalerUriErrorType.BadRequest, "Conditional contract has been deleted.", false);
                    return false;
 
                case ContractState.Obsoleted:
                    Uri.State.Error(Uris.States.EDalerUriErrorType.BadRequest, "Conditional contract has been obsoleted.", false);
                    return false;
 
                case ContractState.Proposed:
                    Uri.State.Error(Uris.States.EDalerUriErrorType.Conflict, "Conditional contract has been proposed, but has not been approved and signed yet.", true);
                    return false;
 
                case ContractState.Rejected:
                    Uri.State.Error(Uris.States.EDalerUriErrorType.BadRequest, "Conditional contract has been rejected.", false);
                    return false;
 
                case ContractState.Failed:
                    Uri.State.Error(Uris.States.EDalerUriErrorType.BadRequest, "Conditional contract has failed.", false);
                    return false;
 
                case ContractState.Signed:
                    if (!await Contract.IsLegallyBinding(true, false, Legal))
                    {
                        Uri.State.Error(Uris.States.EDalerUriErrorType.BadRequest, "Contract not legally binding at the current time.", false);
                        return false;
                    }
                    else
                        return true;
 
                default:
                    Uri.State.Error(Uris.States.EDalerUriErrorType.BadRequest, "Conditional contract is in an invalid state.", false);
                    return false;
            }
        }
 
        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.
        }
    }
}