SellEDaler.cs

using Paiwise;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Runtime.Inventory;
using Waher.Script;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Contracts;
using Waher.Service.IoTBroker.Legal.Identity;
using Waher.Service.IoTBroker.Paiwise;
using Waher.Service.IoTBroker.StateMachines.Exceptions;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Actions.Payments
{
    public class SellEDaler : ActionNode
    {
        private From from;
        private Amount amount;
        private Currency currency;
        private Reference reference;
        private Contract contract;
        private ServiceProvider serviceProvider;
        private ServiceId serviceId;
        private Parameter[] parameters;
 
        public SellEDaler()
            : base()
        {
        }
 
        public From From => this.from;
 
        public Amount Amount => this.amount;
 
        public Currency Currency => this.currency;
 
        public Reference Reference => this.reference;
 
        public Contract Contract => this.contract;
 
        public ServiceProvider ServiceProvider => this.serviceProvider;
 
        public ServiceId ServiceId => this.serviceId;
 
        public Parameter[] Parameters => this.parameters;
 
        public override string LocalName => nameof(SellEDaler);
 
        public override IStateMachineNode Create()
        {
            return new SellEDaler();
        }
 
        public override async Task Parse(XmlElement Xml)
        {
            await base.Parse(Xml);
 
            this.ConvertValueAttributesToElements(Xml,
                new Type[]
                {
                    typeof(From),
                    typeof(Amount),
                    typeof(Currency),
                    typeof(Reference),
                    typeof(Contract),
                    typeof(ServiceProvider),
                    typeof(ServiceId)
                },
                new bool[]
                {
                    true,
                    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.reference = this.GetValueElement<Reference>();
            this.contract = this.GetValueElement<Contract>();
            this.serviceProvider = this.GetValueElement<ServiceProvider>();
            this.serviceId = this.GetValueElement<ServiceId>();
            this.parameters = this.GetChildElements<Parameter>();
        }
 
        public override async Task Execute(EvaluationArguments Arguments)
        {
            string ContractId = (await this.contract.Evaluate(Arguments))?.ToString();
            if (ContractId != (Arguments.Token?.CreationContract ?? Arguments.Machine.DefinitionContractId) &&
                ContractId != Arguments.Token?.OwnershipContract)
            {
                throw new StateMachineException(Arguments.Machine, "Sell eDaler contract reference must be either the creation contract, or the current ownership contract.");
            }
 
            CaseInsensitiveString To = (await this.from.Evaluate(Arguments))?.ToString();
 
            if (To == Arguments.Machine.TrustProvider ||
                To == Arguments.Machine.TrustProviderJid)
            {
                throw new StateMachineException(Arguments.Machine, "Trust Provider not permitted to sell eDaler.");
            }
 
            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();
            string ServiceProvider = (await this.serviceProvider.Evaluate(Arguments))?.ToString();
            string ServiceId = (await this.serviceId.Evaluate(Arguments))?.ToString();
 
            KeyValuePair<Legal.Contracts.Contract, IqResultEventArgs> P = await XmppServerModule.Legal.GetContract(ContractId);
            Legal.Contracts.Contract Contract = P.Key;
 
            if (Contract is null)
            {
                if (string.IsNullOrEmpty(P.Value?.ErrorText))
                    throw new StateMachineException(Arguments.Machine, "Unable to get contract: " + ContractId);
                else
                    throw new StateMachineException(Arguments.Machine, "Unable to get contract " + ContractId + ": " + P.Value.ErrorText);
            }
 
            if (Contract.State != ContractState.Signed)
                throw new StateMachineException(Arguments.Machine, "Contract is not in a signed state.");
 
            if (!await Contract.IsLegallyBinding(true, false, XmppServerModule.Legal))
                throw new StateMachineException(Arguments.Machine, "Contract not legally binding.");
 
            CaseInsensitiveString PaymentLegalId = null;
            CaseInsensitiveString PaymentJid = null;
 
            foreach (ClientSignature Signature in Contract.ClientSignatures)
            {
                if (To == Signature.LegalId || To == Signature.BareJid)
                {
                    PaymentLegalId = Signature.LegalId;
                    PaymentJid = Signature.BareJid;
                    break;
                }
            }
 
            if (PaymentLegalId is null || PaymentJid is null)
                throw new StateMachineException(Arguments.Machine, To + " is not a part of the contract.");
 
            if (string.IsNullOrEmpty(ServiceId))
                throw new StateMachineException(Arguments.Machine, "Unable to sell eDaler: Service ID not defined.");
 
            if (string.IsNullOrEmpty(ServiceProvider))
                throw new StateMachineException(Arguments.Machine, "Unable to sell eDaler: Service Provider not defined.");
 
            Type T = Types.GetType(ServiceProvider)
                ?? throw new StateMachineException(Arguments.Machine, "Unable to sell eDaler: Service Provider " + ServiceProvider + " not found or installed.");
 
            if (!typeof(ISellEDalerServiceProvider).IsAssignableFrom(T) ||
                !(Types.Instantiate(T) is ISellEDalerServiceProvider SellEDalerServiceProvider))
            {
                throw new StateMachineException(Arguments.Machine, "Unable to sell eDaler: Service Provider does not support selling of eDaler.");
            }
 
            if (string.IsNullOrEmpty(Currency))
                throw new StateMachineException(Arguments.Machine, "Unable to sell eDaler: Currency not defined.");
 
            if (Amount <= 0)
                throw new StateMachineException(Arguments.Machine, "Unable to sell eDaler: Amount must be positive.");
 
            XmppAddress PaymentAddress = new XmppAddress(PaymentJid);
            if (!PaymentAddress.HasAccount)
                throw new StateMachineException(Arguments.Machine, "Unable to sell eDaler: Invalid seller JID.");
 
            if (!XmppServerModule.Server.IsServerDomain(PaymentAddress.Domain, true))
                throw new StateMachineException(Arguments.Machine, "Unable to sell eDaler: Seller does not have an account on the current broker.");
 
            LegalIdentity PaymentIdentity = await LegalComponent.GetLocalLegalIdentity(PaymentLegalId)
                ?? throw new StateMachineException(Arguments.Machine, "Unable to get seller legal identity.");
 
            string Country = PaymentIdentity[PersonalInformation.CountryTag];
 
            if (string.IsNullOrEmpty(Country))
                throw new StateMachineException(Arguments.Machine, "Seller legal identity lacks country.");
 
            ISellEDalerService Service = await SellEDalerServiceProvider.GetServiceForSellingEDaler(ServiceId, Currency, Country)
                ?? throw new StateMachineException(Arguments.Machine, "Payment Service ID not found.");
 
            if (!await Service.CanSellEDaler(PaymentAddress.Account))
                throw new StateMachineException(Arguments.Machine, "Unable to sell eDaler: Selected service provider cannot perform action.");
 
            if (Service.Supports(Currency) == Grade.NotAtAll)
                throw new StateMachineException(Arguments.Machine, "Unable to sell eDaler: Selected service provider does not support currency.");
 
            Dictionary<CaseInsensitiveString, object> ContractParameters = new Dictionary<CaseInsensitiveString, object>();
            Dictionary<CaseInsensitiveString, CaseInsensitiveString> SellerIdParameters = new Dictionary<CaseInsensitiveString, CaseInsensitiveString>();
 
            foreach (Parameter P2 in this.parameters)
            {
                string Key = (await P2.Key.Evaluate(Arguments))?.ToString() ?? string.Empty;
                object Value = await P2.Value.Evaluate(Arguments);
 
                ContractParameters[Key] = Value;
            }
 
            foreach (Property P2 in PaymentIdentity.Properties)
                SellerIdParameters[P2.Name] = P2.Value;
 
            PaymentResult Result = await PaiwiseProcessor.SellEDaler(Amount, Currency, null, null, null, Service, 
                XmppServerModule.EDaler, PaymentLegalId, ContractId, ContractParameters, SellerIdParameters, 
                Reference, null, null);
 
            if (!Result.Ok)
                throw new StateMachineException(Arguments.Machine, Result.Error);
        }
 
    }
}