ReserveAmount.cs

using System;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Persistence.Attributes;
using Waher.Script;
using Waher.Service.IoTBroker.Paiwise;
using Waher.Service.IoTBroker.StateMachines.Exceptions;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Actions.Payments
{
    public class ReserveAmount : ActionNode
    {
        private From from;
        private Amount amount;
        private Currency currency;
        private ValidDays validDays;
        private Reference reference;
        private Contract contract;
 
        public ReserveAmount()
            : base()
        {
        }
 
        public From From => this.from;
 
        public Amount Amount => this.amount;
 
        public Currency Currency => this.currency;
 
        public ValidDays ValidDays => this.validDays;
 
        public Reference Reference => this.reference;
 
        public Contract Contract => this.contract;
 
        [DefaultValueNull]
        public string TransactionVariable { get; set; }
 
        public override string LocalName => nameof(ReserveAmount);
 
        public override IStateMachineNode Create()
        {
            return new ReserveAmount();
        }
 
        public override async Task Parse(XmlElement Xml)
        {
            this.TransactionVariable = XML.Attribute(Xml, "transactionVariable");
 
            await base.Parse(Xml);
 
            this.ConvertValueAttributesToElements(Xml,
                new Type[]
                {
                    typeof(From),
                    typeof(Amount),
                    typeof(Currency),
                    typeof(ValidDays),
                    typeof(Reference),
                    typeof(Contract)
                },
                new bool[]
                {
                    true,
                    true,
                    true,
                    true,
                    true,
                    true
                });
        }
 
        protected override void OnChildNodesUpdated()
        {
            base.OnChildNodesUpdated();
 
            this.from = this.GetValueElement<From>();
            this.amount = this.GetValueElement<Amount>();
            this.currency = this.GetValueElement<Currency>();
            this.validDays = this.GetValueElement<ValidDays>();
            this.reference = this.GetValueElement<Reference>();
            this.contract = this.GetValueElement<Contract>();
        }
 
        public override async Task Execute(EvaluationArguments Arguments)
        {
            double ValidDays = Expression.ToDouble(await this.validDays.Evaluate(Arguments));
            if (ValidDays <= 0)
                throw new StateMachineException(Arguments.Machine, "ReserveAmounts must be valid a positive number of days.");
 
            string Contract = (await this.contract.Evaluate(Arguments))?.ToString();
            if (Contract != (Arguments.Token?.CreationContract ?? Arguments.Machine.DefinitionContractId) &&
                Contract != Arguments.Token?.OwnershipContract)
            {
                throw new StateMachineException(Arguments.Machine, "ReserveAmount contract reference must be either the creation contract, or the current ownership contract.");
            }
 
            string From = (await this.from.Evaluate(Arguments))?.ToString();
 
            if (From == Arguments.Machine.TrustProvider ||
                From == Arguments.Machine.TrustProviderJid)
            {
                throw new StateMachineException(Arguments.Machine, "State-Machine payments from trust provider not permitted.");
            }
 
            decimal Amount = Expression.ToDecimal(await this.amount.Evaluate(Arguments));
            string Currency = (await this.currency.Evaluate(Arguments))?.ToString();
            string Reference = (await this.reference.Evaluate(Arguments))?.ToString();
 
            Guid TransactionId = Guid.NewGuid();
            string ReserveAmountUri = PaiwiseProcessor.GenerateReserveAmountUri(TransactionId,
                From, Payment.IsLegalId(From), Currency, Amount, Reference, Contract, ValidDays, out _, out _);
 
            string Msg = await PaiwiseProcessor.ProcessPayment(ReserveAmountUri, Arguments.EDaler);
            if (!string.IsNullOrEmpty(Msg))
                throw new StateMachineException(Arguments.Machine, Msg);
 
            if (!string.IsNullOrEmpty(this.TransactionVariable))
                Arguments.Variables[this.TransactionVariable] = TransactionId.ToString();
        }
 
    }
}