EDalerComponent.cs

using Paiwise;
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Inventory;
using Waher.Runtime.Settings;
using Waher.Runtime.Transactions;
using Waher.Security;
using Waher.Security.LoginMonitor;
using Waher.Security.Users;
using Waher.Service.IoTBroker.EDaler.Transactions;
using Waher.Service.IoTBroker.EDaler.Uris;
using Waher.Service.IoTBroker.EDaler.Uris.States;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Identity;
using Waher.Service.IoTBroker.NeuroFeatures;
using Waher.Service.IoTBroker.StateMachines;
 
namespace Waher.Service.IoTBroker.EDaler
{
    public class EDalerComponent : Component
    {
        public const string NamespaceEDaler = "http://waher.se/Schema/eDaler.xsd";
 
        private readonly Dictionary<string, Wallet> wallets = new Dictionary<string, Wallet>();
        private readonly Transactions<ITransaction> transactions = new Transactions<ITransaction>(TimeSpan.FromMinutes(1));
        private readonly LegalComponent legal;
        private string defaultCurrency = null;
 
        public EDalerComponent(XmppServer Server, CaseInsensitiveString Subdomain, string Name, LegalComponent Legal)
            : base(Server, Subdomain, Name)
        {
            this.legal = Legal;
 
            this.RegisterIqGetHandler("balance", NamespaceEDaler, this.GetWalletBalanceHandler, true);
            this.RegisterIqSetHandler("uri", NamespaceEDaler, this.SetUriHandler, false);
            this.RegisterIqGetHandler("events", NamespaceEDaler, this.GetAccountEventsHandler, false);
            this.RegisterIqSetHandler("execute", NamespaceEDaler, this.ExecuteHandler, false);
            this.RegisterIqSetHandler("commit", NamespaceEDaler, this.CommitHandler, false);
            this.RegisterIqSetHandler("rollback", NamespaceEDaler, this.RollbackHandler, false);
            this.RegisterIqGetHandler("buyEDalerProviders", NamespaceEDaler, this.GetBuyEDalerProvidersHandler, false);
            this.RegisterIqSetHandler("initiateGetOptionsBuyEDaler", NamespaceEDaler, this.InitiateGetOptionsBuyEDalerHandler, false);
            this.RegisterIqSetHandler("initiateBuyEDaler", NamespaceEDaler, this.InitiateBuyEDalerHandler, false);
            this.RegisterIqGetHandler("sellEDalerProviders", NamespaceEDaler, this.GetSellEDalerProvidersHandler, false);
            this.RegisterIqSetHandler("initiateGetOptionsSellEDaler", NamespaceEDaler, this.InitiateGetOptionsSellEDalerHandler, false);
            this.RegisterIqSetHandler("initiateSellEDaler", NamespaceEDaler, this.InitiateSellEDalerHandler, false);
 
            NeuroFeaturesProcessor.RegisterHandlers(this);
            StateMachineProcessor.RegisterHandlers(this);
        }
 
        public override void Dispose()
        {
            this.transactions.Dispose();
 
            this.UnregisterIqGetHandler("balance", NamespaceEDaler, this.GetWalletBalanceHandler, true);
            this.UnregisterIqSetHandler("uri", NamespaceEDaler, this.SetUriHandler, false);
            this.UnregisterIqGetHandler("events", NamespaceEDaler, this.GetAccountEventsHandler, false);
            this.UnregisterIqSetHandler("execute", NamespaceEDaler, this.ExecuteHandler, false);
            this.UnregisterIqSetHandler("commit", NamespaceEDaler, this.CommitHandler, false);
            this.UnregisterIqSetHandler("rollback", NamespaceEDaler, this.RollbackHandler, false);
            this.UnregisterIqGetHandler("buyEDalerProviders", NamespaceEDaler, this.GetBuyEDalerProvidersHandler, false);
            this.UnregisterIqSetHandler("initiateGetOptionsBuyEDaler", NamespaceEDaler, this.InitiateGetOptionsBuyEDalerHandler, false);
            this.UnregisterIqSetHandler("initiateBuyEDaler", NamespaceEDaler, this.InitiateBuyEDalerHandler, false);
            this.UnregisterIqGetHandler("sellEDalerProviders", NamespaceEDaler, this.GetSellEDalerProvidersHandler, false);
            this.UnregisterIqSetHandler("initiateGetOptionsSellEDaler", NamespaceEDaler, this.InitiateGetOptionsSellEDalerHandler, false);
            this.UnregisterIqSetHandler("initiateSellEDaler", NamespaceEDaler, this.InitiateSellEDalerHandler, false);
 
            NeuroFeaturesProcessor.UnregisterHandlers(this);
            StateMachineProcessor.UnregisterHandlers(this);
        }
 
        public override bool SupportsAccounts => false;
 
        public LegalComponent Legal => this.legal;
 
        public async Task<string> GetDefaultCurrency()
        {
            this.defaultCurrency ??= await RuntimeSettings.GetAsync("DefaultCurrency", "EUR");
            return this.defaultCurrency;
        }
 
        internal async Task<Wallet> GetWallet(CaseInsensitiveString AccountName, CaseInsensitiveString Domain)
        {
            string Key = AccountName.LowerCase + "@" + Domain.LowerCase;
            Wallet Wallet;
 
            lock (this.wallets)
            {
                if (this.wallets.TryGetValue(Key, out Wallet))
                    return Wallet;
            }
 
            bool Created = false;
 
            Wallet = await Database.FindFirstDeleteRest<Wallet>(
                new FilterAnd(
                new FilterFieldEqualTo("Account", AccountName),
                new FilterCustom<Wallet>((Obj)=>
                {
                    return Obj.Domain == Domain || CaseInsensitiveString.IsNullOrEmpty(Obj.Domain);
                })), "Created");
 
            if (Wallet is null)
            {
                Wallet = new Wallet()
                {
                    Account = AccountName,
                    Domain = Domain,
                    Currency = await this.GetDefaultCurrency(),
                    Created = DateTime.Now
                };
 
                Created = true;
            }
            else if (string.IsNullOrEmpty(Wallet.Currency))
            {
                Wallet.Currency = await this.GetDefaultCurrency();
                await Database.Update(Wallet);
            }
 
            lock (this.wallets)
            {
                if (this.wallets.TryGetValue(Key, out Wallet Wallet2))
                    return Wallet2;
                else
                    this.wallets[Key] = Wallet;
            }
 
            if (Created)
                await Database.Insert(Wallet);
 
            return Wallet;
        }
 
        private async Task GetWalletBalanceHandler(object Sender, IqEventArgs e)
        {
            if (!this.Server.IsServerDomain(e.From.Domain, true) || !e.From.HasAccount)
            {
                await e.IqErrorForbidden(e.To, "Access to wallet only granted to accounts on broker.", "en");
                return;
            }
 
            CaseInsensitiveString AccountName = e.From.Account;
            IAccount Account = await XmppServerModule.GetAccountAsync(AccountName);
            if (Account is null)
            {
                await e.IqErrorForbidden(e.To, "Access to wallet only granted to accounts on broker.", "en");
                return;
            }
 
            if (!Account.Enabled)
            {
                await e.IqErrorForbidden(e.To, "Account has been disabled.", "en");
                return;
            }
 
            await e.IqResult(await this.GetWalletBalanceXml(AccountName, e.From.Domain, null), e.To);
        }
 
        internal async Task<string> GetWalletBalanceXml(CaseInsensitiveString AccountName, CaseInsensitiveString Domain, AccountEvent Event)
        {
            Wallet Wallet = await this.GetWallet(AccountName, Domain);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<balance xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("' amount='");
            Xml.Append(CommonTypes.Encode(Wallet.Balance));
 
            if (Wallet.Reserved != 0)
            {
                Xml.Append("' reserved='");
                Xml.Append(CommonTypes.Encode(Wallet.Reserved));
            }
 
            Xml.Append("' currency='");
            Xml.Append(XML.Encode(Wallet.Currency));
            Xml.Append("' timestamp='");
            Xml.Append(XML.Encode(Wallet.BalanceTimestamp));
 
            if (Event is null)
                Xml.Append("'/>");
            else
            {
                Xml.Append("'>");
                Event.ToXml(Xml);
                Xml.Append("</balance>");
            }
 
            return Xml.ToString();
        }
 
        public static bool IsValidCurrencySymbol(string Currency)
        {
            if (Currency.Length > 5)
                return false;
 
            Currency = Currency.ToUpper();
 
            foreach (char ch in Currency)
            {
                if (ch < 'A' || ch > 'Z')
                    return false;
            }
 
            return true;
        }
 
        public static Task<string> GenerateIssueUrl(decimal Amount, string Currency, int ExpiresDays, string FreeText,
            string ManagerPassword, HttpRequest Request, IUser User)
        {
            return GenerateIssueUrl(string.Empty, Amount, Currency, ExpiresDays, FreeText, ManagerPassword, Request, User);
        }
 
        public static async Task<string> GenerateIssueUrl(string To, decimal Amount, string Currency, int ExpiresDays, string FreeText,
            string ManagerPassword, HttpRequest Request, IUser User)
        {
            if (User is null || !(User?.HasPrivilege("Admin.eDaler.Generate") ?? false))
                throw new ForbiddenException(Request, "Insufficient privileges.");
 
            string Uri = await GenerateUrl(To, Amount, Currency, ExpiresDays, FreeText, ManagerPassword, Request, User, "is", true);
            KeyValuePair<string, object>[] Tags = await GetTags(Amount, Currency, ExpiresDays, FreeText, Request);
 
            Log.Notice("URI created for eDaler creation.", XmppServerModule.Server.Domain, User.UserName,
                "eDalerIssueUri", EventLevel.Major, Tags);
 
            return Uri;
        }
 
        public static async Task<string> GenerateDestroyUrl(decimal Amount, string Currency, int ExpiresDays, string FreeText,
            string ManagerPassword, HttpRequest Request, IUser User)
        {
            if (User is null || !(User?.HasPrivilege("Admin.eDaler.Destroy") ?? false))
                throw new ForbiddenException(Request, "Insufficient privileges.");
 
            string Uri = await GenerateUrl(string.Empty, Amount, Currency, ExpiresDays, FreeText, ManagerPassword, Request, User, "xx", false);
            KeyValuePair<string, object>[] Tags = await GetTags(Amount, Currency, ExpiresDays, FreeText, Request);
 
            Log.Notice("URI created for eDaler destruction.", XmppServerModule.Server.Domain, User.UserName,
                "eDalerDestroyUri", EventLevel.Major, Tags);
 
            return Uri;
        }
 
        private async static Task<KeyValuePair<string, object>[]> GetTags(decimal Amount, string Currency, int ExpiresDays, string FreeText, HttpRequest Request)
        {
            return await LoginAuditor.Annotate(Request.RemoteEndPoint,
                new KeyValuePair<string, object>("Amount", Amount),
                new KeyValuePair<string, object>("Currency", Currency),
                new KeyValuePair<string, object>("ExpiresDays", ExpiresDays),
                new KeyValuePair<string, object>("FreeText", FreeText),
                new KeyValuePair<string, object>("RemoteEndpoint", Request.RemoteEndPoint));
        }
 
        private static async Task<string> GenerateUrl(string To, decimal Amount, string Currency, int ExpiresDays, string FreeText, string ManagerPassword,
            HttpRequest Request, IUser User, string Command, bool Sign)
        {
            if (Amount <= 0)
                throw new ArgumentException("Amount must be positive.", nameof(Amount));
 
            if (string.IsNullOrEmpty(Currency))
                throw new ArgumentException("No currency specified.");
 
            if (!IsValidCurrencySymbol(Currency))
                throw new ArgumentException("Invalid currency symbol.");
 
            if (ExpiresDays <= 0)
                throw new ArgumentException("Expiry interval must be positive.", nameof(Amount));
 
            if (string.IsNullOrEmpty(FreeText))
                throw new ArgumentException("No free text specified.");
 
            if (User is null || string.IsNullOrEmpty(User.UserName))
                throw new ForbiddenException(Request, "Invalid user.");
 
            // Double check manager password
 
            LoginResult Result = await Users.Login(User.UserName, ManagerPassword, Request.RemoteEndPoint, "Web");
 
            switch (Result.Type)
            {
                case LoginResultType.PermanentlyBlocked:
                    StringBuilder sb = new StringBuilder();
 
                    sb.Append("This endpoint (");
                    sb.Append(Request.RemoteEndPoint);
                    sb.Append(") has been blocked from the system.");
 
                    throw new ForbiddenException(Request, sb.ToString());
 
                case LoginResultType.TemporarilyBlocked:
                    sb = new StringBuilder();
                    DateTime TP = Result.Next.Value;
                    DateTime Today = DateTime.Today;
 
                    sb.Append("Too many failed login attempts in a row registered. Try again after ");
                    sb.Append(TP.ToLongTimeString());
 
                    if (TP.Date != Today)
                    {
                        if (TP.Date == Today.AddDays(1))
                            sb.Append(" tomorrow");
                        else
                        {
                            sb.Append(", ");
                            sb.Append(TP.ToShortDateString());
                        }
                    }
 
                    sb.Append(". Remote Endpoint: ");
                    sb.Append(Request.RemoteEndPoint);
 
                    throw new ForbiddenException(Request, sb.ToString());
 
                case LoginResultType.NoPassword:
                    throw new ForbiddenException(Request, "No password provided.");
 
                case LoginResultType.InvalidCredentials:
                default:
                    throw new ForbiddenException(Request, "Invalid login credentials provided.");
 
                case LoginResultType.Success:
                    break;
            }
 
            // Generate URI
 
            StringBuilder Uri = new StringBuilder();
            Guid Id = Guid.NewGuid();
            DateTime Created = DateTime.UtcNow;
 
            Uri.Append("edaler:");
            Uri.Append(Command);
            Uri.Append('=');
            Uri.Append(XmppServerModule.Server.Domain);
            Uri.Append(";id=");
            Uri.Append(Id.ToString());
 
            if (!string.IsNullOrEmpty(To))
            {
                int i = To.IndexOf('@');
                if (i > 0 && Guid.TryParse(To[..i], out _))
                    Uri.Append("ti=");
                else
                    Uri.Append("t=");
 
                Uri.Append(To);
            }
 
            Uri.Append(";cr=");
            Uri.Append(XML.Encode(Created, false));
            Uri.Append(";am=");
            Uri.Append(CommonTypes.Encode(Amount));
            Uri.Append(";cu=");
            Uri.Append(Currency);
            Uri.Append(";ex=");
            Uri.Append(XML.Encode(Created.Date.AddDays(ExpiresDays), true));
            Uri.Append(";m=");
            Uri.Append(Convert.ToBase64String(Encoding.UTF8.GetBytes(FreeText)));
 
            if (Sign)
            {
                byte[] PreSign = Encoding.UTF8.GetBytes(Uri.ToString());
                byte[] S = XmppServerModule.Legal.Sign(PreSign);
 
                Uri.Append(";s=");
                Uri.Append(Convert.ToBase64String(S));
            }
 
            return Uri.ToString();
        }
 
        private async Task SetUriHandler(object Sender, IqEventArgs e)
        {
            if (!TransactionModule.Running)
            {
                await e.IqErrorServiceUnavailable(e.To, "Transaction module not running.", "en");
                return;
            }
 
            if (e.From.HasAccount && !this.Server.IsServerDomain(e.From.Domain, true))
            {
                await e.IqErrorForbidden(e.To, "Access to wallet only granted to accounts on broker.", "en");
                return;
            }
 
            string UriString = e.Query.InnerText;
            EDalerUriState State = new ExternalRequest(e);
            EDalerUri Uri = await EDalerUri.Parse(UriString, State, this);
            if (Uri is null)
                return;
 
            if (await this.ProcessUri(Uri, e.From))
                await e.IqResult(string.Empty, e.To);
        }
 
        public async Task<string> ProcessUri(string Uri, string From)
        {
            InternalProcessing State = new InternalProcessing(Uri);
 
            EDalerUri ParsedUri = await EDalerUri.Parse(Uri, State, this);
            if (ParsedUri is null)
                return string.IsNullOrEmpty(State.ErrorMessage) ? "Unable to parse eDaler URI." : State.ErrorMessage;
 
            XmppAddress ParsedFrom = new XmppAddress(From);
 
            if (!await this.ProcessUri(ParsedUri, ParsedFrom))
                return string.IsNullOrEmpty(State.ErrorMessage) ? "Unable to process eDaler URI." : State.ErrorMessage;
 
            return null;
        }
 
        internal async Task<bool> ProcessUri(EDalerUri Uri, XmppAddress From)
        {
            ITransaction UriTransaction;
            bool OnPrincipal = this.Server.IsServerDomain(Uri.PrincipalDomain, true);
            bool FromPrincipal = From.Address == Uri.PrincipalDomain;
            bool RemotelyControlled = false;
            bool ContractualPayment = Uri is EDalerContractualPaymentUri;
 
            if (OnPrincipal || FromPrincipal || ContractualPayment)
            {
                RemotelyControlled = (!OnPrincipal && FromPrincipal) || ContractualPayment;
 
                List<ITransaction> Parts = new List<ITransaction>();
                Uri.AddTransactionParts(Parts, RemotelyControlled, this.legal);
 
                if (Parts.Count == 1)
                    UriTransaction = Parts[0];
                else
                    UriTransaction = new CompositeTransaction(Uri.Id, true, Parts.ToArray());
            }
            else
                UriTransaction = new RelayToPrimary(Uri);
 
            try
            {
                if (!await UriTransaction.Prepare())
                {
                    Uri.State.Error(EDalerUriErrorType.BadRequest, "Unable to prepare URI for processing.", false);
                    return false;
                }
            }
            catch (Exception ex)
            {
                Uri.State.Error(ex);
                return false;
            }
 
            if (RemotelyControlled)
            {
                UriTransaction.Tag = new RemoteControlState()
                {
                    From = From.BareJid,
                    Uri = Uri
                };
 
                this.transactions.Register(UriTransaction);
 
                return true;
            }
            else
            {
                try
                {
                    if (await UriTransaction.Execute())
                    {
                        if (await UriTransaction.Commit())
                            return false;
                        else
                            await UriTransaction.Rollback();
                    }
                    else
                        await UriTransaction.Rollback();
 
                    Uri.State.Error(EDalerUriErrorType.ResourceConstraint, "Unable to process transaction.", false);
                }
                catch (Exception ex)
                {
                    await UriTransaction.Abort();
 
                    Uri.State.Error(ex);
                }
            }
 
            return false;
        }
 
        private class RemoteControlState
        {
            public CaseInsensitiveString From;
            public EDalerUri Uri;
        }
 
        private async Task ExecuteHandler(object Sender, IqEventArgs e)
        {
            ITransaction Transaction = await this.PrepareTransaction(e);
            if (Transaction is null)
                return;
 
            try
            {
                if (!await Transaction.Execute())
                {
                    if (Transaction.Tag is RemoteControlState State)
                        await e.IqErrorConflict(e.To, "Unable to execute transaction: " + State.Uri.State.ErrorMessage, "en");
                    else
                        await e.IqErrorConflict(e.To, "Unable to execute transaction.", "en");
 
                    return;
                }
            }
            catch (Exception ex)
            {
                await e.IqError(ex, e.To);
                return;
            }
 
            await e.IqResult(string.Empty, e.To);
        }
 
        private async Task<ITransaction> PrepareTransaction(IqEventArgs e)
        {
            string IdStr = XML.Attribute(e.Query, "id");
 
            if (!Guid.TryParse(IdStr, out Guid Id))
            {
                await e.IqErrorBadRequest(e.To, "Invalid transaction ID.", "en");
                return null;
            }
 
            if (!this.transactions.TryGetTransaction(Id, out ITransaction Transaction))
            {
                await e.IqErrorItemNotFound(e.To, "An active transaction with the given ID was not found.", "en");
                return null;
            }
 
            if (!(Transaction.Tag is RemoteControlState State) || State.From != e.From.BareJid)
            {
                await e.IqErrorForbidden(e.To, "You are not authorized to control this transaction.", "en");
                return null;
            }
 
            State.Uri.State = new InternalProcessing(State.Uri.UriString);
 
            return Transaction;
        }
 
        private async Task CommitHandler(object Sender, IqEventArgs e)
        {
            ITransaction Transaction = await this.PrepareTransaction(e);
            if (Transaction is null)
                return;
 
            try
            {
                if (!await Transaction.Commit())
                {
                    if (Transaction.Tag is RemoteControlState State)
                        await e.IqErrorConflict(e.To, "Unable to commit transaction: " + State.Uri.State.ErrorMessage, "en");
                    else
                        await e.IqErrorConflict(e.To, "Unable to commit transaction.", "en");
 
                    return;
                }
 
                this.transactions.Unregister(Transaction);
            }
            catch (Exception ex)
            {
                await e.IqError(ex, e.To);
                return;
            }
 
            await e.IqResult(string.Empty, e.To);
        }
 
        private async Task RollbackHandler(object Sender, IqEventArgs e)
        {
            ITransaction Transaction = await this.PrepareTransaction(e);
            if (Transaction is null)
                return;
 
            try
            {
                if (!await Transaction.Rollback())
                {
                    if (Transaction.Tag is RemoteControlState State)
                        await e.IqErrorConflict(e.To, "Unable to roll transaction back: " + State.Uri.State.ErrorMessage, "en");
                    else
                        await e.IqErrorConflict(e.To, "Unable to roll transaction back.", "en");
 
                    return;
                }
 
                this.transactions.Unregister(Transaction);
            }
            catch (Exception ex)
            {
                await e.IqError(ex, e.To);
                return;
            }
 
            await e.IqResult(string.Empty, e.To);
        }
 
        private async Task GetAccountEventsHandler(object Sender, IqEventArgs e)
        {
            if (!this.Server.IsServerDomain(e.From.Domain, true) || !e.From.HasAccount)
            {
                await e.IqErrorForbidden(e.To, "Access to wallet only granted to accounts on broker.", "en");
                return;
            }
 
            CaseInsensitiveString AccountName = e.From.Account;
            IAccount Account = await XmppServerModule.GetAccountAsync(AccountName);
            if (Account is null)
            {
                await e.IqErrorForbidden(e.To, "Access to wallet only granted to accounts on broker.", "en");
                return;
            }
 
            if (!Account.Enabled)
            {
                await e.IqErrorForbidden(e.To, "Account has been disabled.", "en");
                return;
            }
 
            IEnumerable<AccountEvent> Events;
            int MaxCount = XML.Attribute(e.Query, "maxCount", 20);
            if (MaxCount > 100)
                MaxCount = 100;
 
            if (!e.Query.HasAttribute("from") ||
                !XML.TryParse(e.Query.GetAttribute("from"), out DateTime From))
            {
                Events = await Database.Find<AccountEvent>(0, MaxCount + 1,
                    new FilterFieldEqualTo("Account", Account.UserName), "-Timestamp");
            }
            else
            {
                Events = await Database.Find<AccountEvent>(0, MaxCount + 1, new FilterAnd(
                    new FilterFieldEqualTo("Account", Account.UserName),
                    new FilterFieldLesserThan("Timestamp", From)), "-Timestamp");
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<events xmlns=\"");
            Xml.Append(NamespaceEDaler);
            Xml.Append("\">");
 
            foreach (AccountEvent Event in Events)
            {
                if (MaxCount-- <= 0)
                {
                    Xml.Append("<more/>");
                    break;
                }
 
                Event.ToXml(Xml);
            }
 
            Xml.Append("</events>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private async Task GetBuyEDalerProvidersHandler(object Sender, IqEventArgs e)
        {
            if (!this.Server.IsServerDomain(e.From.Domain, true) || !e.From.HasAccount)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            CaseInsensitiveString AccountName = e.From.Account;
            IAccount Account = await XmppServerModule.GetAccountAsync(AccountName);
            if (Account is null)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            if (!Account.Enabled)
            {
                await e.IqErrorForbidden(e.To, "Account has been disabled.", "en");
                return;
            }
 
            LegalIdentity Identity = await this.legal.GetCurrentApprovedLegalIdentityAsync(AccountName);
            if (Identity is null)
            {
                await e.IqErrorForbidden(e.To, "Account has no approved legal identity.", "en");
                return;
            }
 
            string Country = Identity[PersonalInformation.CountryTag];
            if (string.IsNullOrEmpty(Country))
            {
                await e.IqErrorForbidden(e.To, "Approved legal identity lacks country specified.", "en");
                return;
            }
 
            Wallet Wallet = await this.GetWallet(AccountName, e.From.Domain);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<providers xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("'>");
 
            Type[] ServiceTypes = Types.GetTypesImplementingInterface(typeof(IBuyEDalerServiceProvider));
 
            foreach (Type T in ServiceTypes)
            {
                ConstructorInfo CI = Types.GetDefaultConstructor(T);
                if (CI is null)
                    continue;
 
                IBuyEDalerServiceProvider Provider = (IBuyEDalerServiceProvider)CI.Invoke(Types.NoParameters);
                IBuyEDalerService[] Services = await Provider.GetServicesForBuyingEDaler(Wallet.Currency, Country);
 
                foreach (IBuyEDalerService Service in Services)
                {
                    if (!await Service.CanBuyEDaler(AccountName))
                        continue;
 
                    Xml.Append("<provider id='");
                    Xml.Append(XML.Encode(Service.Id));
                    Xml.Append("' type='");
                    Xml.Append(XML.Encode(T.FullName));
                    Xml.Append("' name='");
                    Xml.Append(XML.Encode(Service.Name));
 
                    if (!string.IsNullOrEmpty(Service.IconUrl))
                    {
                        Xml.Append("' iconUrl='");
                        Xml.Append(XML.Encode(Service.IconUrl));
                        Xml.Append("' iconWidth='");
                        Xml.Append(Service.IconWidth.ToString());
                        Xml.Append("' iconHeight='");
                        Xml.Append(Service.IconHeight.ToString());
                    }
 
                    if (!string.IsNullOrEmpty(Service.BuyEDalerTemplateContractId))
                    {
                        Xml.Append("' templateId='");
                        Xml.Append(XML.Encode(Service.BuyEDalerTemplateContractId));
                    }
 
                    Xml.Append("'/>");
                }
            }
 
            Xml.Append("</providers>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private async Task InitiateGetOptionsBuyEDalerHandler(object Sender, IqEventArgs e)
        {
            if (!this.Server.IsServerDomain(e.From.Domain, true) || !e.From.HasAccount)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            CaseInsensitiveString AccountName = e.From.Account;
            IAccount Account = await XmppServerModule.GetAccountAsync(AccountName);
            if (Account is null)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            if (!Account.Enabled)
            {
                await e.IqErrorForbidden(e.To, "Account has been disabled.", "en");
                return;
            }
 
            LegalIdentity Identity = await this.legal.GetCurrentApprovedLegalIdentityAsync(AccountName);
            if (Identity is null)
            {
                await e.IqErrorForbidden(e.To, "Account has no approved legal identity.", "en");
                return;
            }
 
            string Country = Identity[PersonalInformation.CountryTag];
            if (string.IsNullOrEmpty(Country))
            {
                await e.IqErrorForbidden(e.To, "Approved legal identity lacks country specified.", "en");
                return;
            }
 
            string ServiceId = XML.Attribute(e.Query, "serviceId");
            string ServiceProvider = XML.Attribute(e.Query, "serviceProvider");
            string SuccessUrl = XML.Attribute(e.Query, "successUrl");
            string FailureUrl = XML.Attribute(e.Query, "failureUrl");
            string CancelUrl = XML.Attribute(e.Query, "cancelUrl");
            string TransactionId = e.Query.HasAttribute("tid") ? XML.Attribute(e.Query, "tid") : Guid.NewGuid().ToString();
 
            if (string.IsNullOrEmpty(ServiceId))
            {
                await e.IqErrorBadRequest(e.To, "Service ID not defined.", "en");
                return;
            }
 
            if (string.IsNullOrEmpty(ServiceProvider))
            {
                await e.IqErrorBadRequest(e.To, "Service Provider not defined.", "en");
                return;
            }
 
            Type T = Types.GetType(ServiceProvider);
            if (T is null)
            {
                await e.IqErrorItemNotFound(e.To, "Service Provider " + ServiceProvider + " not found or installed.", "en");
                return;
            }
 
            if (!typeof(IBuyEDalerServiceProvider).IsAssignableFrom(T) ||
                !(Types.Instantiate(T) is IBuyEDalerServiceProvider BuyEDalerServiceProvider))
            {
                await e.IqErrorBadRequest(e.To, "Service Provider does not support buying of eDaler.", "en");
                return;
            }
 
            Wallet Wallet = await this.GetWallet(AccountName, e.From.Domain);
            IBuyEDalerService Service = await BuyEDalerServiceProvider.GetServiceForBuyingEDaler(ServiceId, Wallet.Currency, Country);
 
            if (Service is null)
            {
                await e.IqErrorItemNotFound(e.To, "Payment Service ID not found.", "en");
                return;
            }
 
            if (!await Service.CanBuyEDaler(AccountName))
            {
                await e.IqErrorNotAllowed(e.To, "Selected service provider cannot perform action.", "en");
                return;
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<transaction xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("' tid='");
            Xml.Append(XML.Encode(TransactionId));
            Xml.Append("'/>");
 
            await e.IqResult(Xml.ToString(), e.To);
 
            Task _ = Task.Run(async () =>
            {
                try
                {
                    Dictionary<CaseInsensitiveString, CaseInsensitiveString> BuyerIdParameters = new Dictionary<CaseInsensitiveString, CaseInsensitiveString>();
 
                    foreach (Property P in Identity.Properties)
                        BuyerIdParameters[P.Name] = P.Value;
 
                    IDictionary<CaseInsensitiveString, object>[] Options;
 
                    try
                    {
                        Options = await Service.GetPaymentOptionsForBuyingEDaler(BuyerIdParameters,
                            SuccessUrl, FailureUrl, CancelUrl, async (sender, e2) =>
                            {
                                Xml.Clear();
 
                                Xml.Append("<buyEDalerOptionsClientUrl xmlns='");
                                Xml.Append(NamespaceEDaler);
                                Xml.Append("' tid='");
                                Xml.Append(XML.Encode(TransactionId));
                                Xml.Append("' url='");
                                Xml.Append(XML.Encode(e2.Url));
                                Xml.Append("'/>");
 
                                await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                                // Note: Client may have a new XMPP connection at this point.
                            }, null);
 
                        Xml.Clear();
 
                        Xml.Append("<buyEDalerOptionsCompleted xmlns='");
                        Xml.Append(NamespaceEDaler);
                        Xml.Append("' tid='");
                        Xml.Append(XML.Encode(TransactionId));
                        Xml.Append("'>");
 
                        if (!(Options is null))
                        {
                            foreach (IDictionary<CaseInsensitiveString, object> Option in Options)
                            {
                                Xml.Append("<option>");
 
                                foreach (KeyValuePair<CaseInsensitiveString, object> P in Option)
                                    StateMachineProcessor.AppendVariable(Xml, P.Key.Value, P.Value);
 
                                Xml.Append("</option>");
                            }
                        }
 
                        Xml.Append("</buyEDalerOptionsCompleted>");
 
                        await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                        // Note: Client may have displayed web URL and have a new XMPP connection at this point.
                    }
                    catch (Exception ex)
                    {
                        Xml.Clear();
 
                        Xml.Append("<buyEDalerOptionsError xmlns='");
                        Xml.Append(NamespaceEDaler);
                        Xml.Append("' tid='");
                        Xml.Append(XML.Encode(TransactionId));
                        Xml.Append("'>");
                        Xml.Append(XML.Encode(ex.Message));
                        Xml.Append("</buyEDalerOptionsError>");
 
                        await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                        // Note: Client may have displayed web URL and have a new XMPP connection at this point.
                    }
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
        }
 
        private async Task InitiateBuyEDalerHandler(object Sender, IqEventArgs e)
        {
            if (!this.Server.IsServerDomain(e.From.Domain, true) || !e.From.HasAccount)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            CaseInsensitiveString AccountName = e.From.Account;
            IAccount Account = await XmppServerModule.GetAccountAsync(AccountName);
            if (Account is null)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            if (!Account.Enabled)
            {
                await e.IqErrorForbidden(e.To, "Account has been disabled.", "en");
                return;
            }
 
            LegalIdentity Identity = await this.legal.GetCurrentApprovedLegalIdentityAsync(AccountName);
            if (Identity is null)
            {
                await e.IqErrorForbidden(e.To, "Account has no approved legal identity.", "en");
                return;
            }
 
            string Country = Identity[PersonalInformation.CountryTag];
            if (string.IsNullOrEmpty(Country))
            {
                await e.IqErrorForbidden(e.To, "Approved legal identity lacks country specified.", "en");
                return;
            }
 
            string ServiceId = XML.Attribute(e.Query, "serviceId");
            string ServiceProvider = XML.Attribute(e.Query, "serviceProvider");
            decimal Amount = XML.Attribute(e.Query, "amount", 0M);
            CaseInsensitiveString Currency = XML.Attribute(e.Query, "currency");
            string SuccessUrl = XML.Attribute(e.Query, "successUrl");
            string FailureUrl = XML.Attribute(e.Query, "failureUrl");
            string CancelUrl = XML.Attribute(e.Query, "cancelUrl");
            string TransactionId = e.Query.HasAttribute("tid") ? XML.Attribute(e.Query, "tid") : Guid.NewGuid().ToString();
 
            if (Amount <= 0)
            {
                await e.IqErrorBadRequest(e.To, "Invalid amount.", "en");
                return;
            }
 
            if (CaseInsensitiveString.IsNullOrEmpty(Currency))
            {
                await e.IqErrorBadRequest(e.To, "Invalid currency.", "en");
                return;
            }
 
            if (string.IsNullOrEmpty(ServiceId))
            {
                await e.IqErrorBadRequest(e.To, "Service ID not defined.", "en");
                return;
            }
 
            if (string.IsNullOrEmpty(ServiceProvider))
            {
                await e.IqErrorBadRequest(e.To, "Service Provider not defined.", "en");
                return;
            }
 
            Type T = Types.GetType(ServiceProvider);
            if (T is null)
            {
                await e.IqErrorItemNotFound(e.To, "Service Provider " + ServiceProvider + " not found or installed.", "en");
                return;
            }
 
            if (!typeof(IBuyEDalerServiceProvider).IsAssignableFrom(T) ||
                !(Types.Instantiate(T) is IBuyEDalerServiceProvider BuyEDalerServiceProvider))
            {
                await e.IqErrorBadRequest(e.To, "Service Provider does not support buying of eDaler.", "en");
                return;
            }
 
            IBuyEDalerService Service = await BuyEDalerServiceProvider.GetServiceForBuyingEDaler(ServiceId, Currency, Country);
 
            if (Service is null)
            {
                await e.IqErrorItemNotFound(e.To, "Payment Service ID not found.", "en");
                return;
            }
 
            if (!await Service.CanBuyEDaler(AccountName))
            {
                await e.IqErrorNotAllowed(e.To, "Selected service provider cannot perform action.", "en");
                return;
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(Currency) && Service.Supports(Currency) == Grade.NotAtAll)
            {
                await e.IqErrorNotAllowed(e.To, "Selected service provider does not support selected currency (" + Currency + ").", "en");
                return;
            }
 
            if (!string.IsNullOrEmpty(Service.BuyEDalerTemplateContractId))
            {
                await e.IqErrorForbidden(e.To, "Service provider requires a signed contract to perform payment. See associated Contract Template ID.", "en");
                return;
            }
 
            Dictionary<CaseInsensitiveString, object> ContractParameters = new Dictionary<CaseInsensitiveString, object>()
            {
                { "Amount", Amount },
                { "Currency", Currency.Value.ToUpper() }
            };
            Dictionary<CaseInsensitiveString, CaseInsensitiveString> BuyerIdParameters = new Dictionary<CaseInsensitiveString, CaseInsensitiveString>();
 
            foreach (Property P in Identity.Properties)
                BuyerIdParameters[P.Name] = P.Value;
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<transaction xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("' tid='");
            Xml.Append(XML.Encode(TransactionId));
            Xml.Append("'/>");
 
            await e.IqResult(Xml.ToString(), e.To);
 
            Task _ = Task.Run(async () =>
            {
                try
                {
                    PaymentResult PaymentResult = await Paiwise.PaiwiseProcessor.BuyEDaler(Amount, Currency, SuccessUrl,
                        FailureUrl, CancelUrl, Service, this, Identity.Id, null, ContractParameters, BuyerIdParameters, TransactionId,
                        async (sender, e2) =>
                        {
                            Xml.Clear();
 
                            Xml.Append("<buyEDalerClientUrl xmlns='");
                            Xml.Append(NamespaceEDaler);
                            Xml.Append("' tid='");
                            Xml.Append(XML.Encode(TransactionId));
                            Xml.Append("' url='");
                            Xml.Append(XML.Encode(e2.Url));
                            Xml.Append("'/>");
 
                            await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                            // Note: Client may have a new XMPP connection at this point.
                        }, null);
 
                    if (PaymentResult.Ok)
                    {
                        Xml.Clear();
 
                        Xml.Append("<buyEDalerCompleted xmlns='");
                        Xml.Append(NamespaceEDaler);
                        Xml.Append("' tid='");
                        Xml.Append(XML.Encode(TransactionId));
                        Xml.Append("' amount='");
                        Xml.Append(CommonTypes.Encode(PaymentResult.Amount));
                        Xml.Append("' currency='");
                        Xml.Append(XML.Encode(PaymentResult.Currency));
                        Xml.Append("'/>");
 
                        await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                        // Note: Client may have displayed web URL and have a new XMPP connection at this point.
                    }
                    else
                    {
                        Xml.Clear();
 
                        Xml.Append("<buyEDalerError xmlns='");
                        Xml.Append(NamespaceEDaler);
                        Xml.Append("' tid='");
                        Xml.Append(XML.Encode(TransactionId));
                        Xml.Append("'>");
                        Xml.Append(XML.Encode(PaymentResult.Error));
                        Xml.Append("</buyEDalerError>");
 
                        await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                        // Note: Client may have displayed web URL and have a new XMPP connection at this point.
                    }
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
        }
 
        private async Task GetSellEDalerProvidersHandler(object Sender, IqEventArgs e)
        {
            if (!this.Server.IsServerDomain(e.From.Domain, true) || !e.From.HasAccount)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            CaseInsensitiveString AccountName = e.From.Account;
            IAccount Account = await XmppServerModule.GetAccountAsync(AccountName);
            if (Account is null)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            if (!Account.Enabled)
            {
                await e.IqErrorForbidden(e.To, "Account has been disabled.", "en");
                return;
            }
 
            LegalIdentity Identity = await this.legal.GetCurrentApprovedLegalIdentityAsync(AccountName);
            if (Identity is null)
            {
                await e.IqErrorForbidden(e.To, "Account has no approved legal identity.", "en");
                return;
            }
 
            string Country = Identity[PersonalInformation.CountryTag];
            if (string.IsNullOrEmpty(Country))
            {
                await e.IqErrorForbidden(e.To, "Approved legal identity lacks country specified.", "en");
                return;
            }
 
            Wallet Wallet = await this.GetWallet(AccountName, e.From.Domain);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<providers xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("'>");
 
            Type[] ServiceTypes = Types.GetTypesImplementingInterface(typeof(ISellEDalerServiceProvider));
 
            foreach (Type T in ServiceTypes)
            {
                ConstructorInfo CI = Types.GetDefaultConstructor(T);
                if (CI is null)
                    continue;
 
                ISellEDalerServiceProvider Provider = (ISellEDalerServiceProvider)CI.Invoke(Types.NoParameters);
                ISellEDalerService[] Services = await Provider.GetServicesForSellingEDaler(Wallet.Currency, Country);
 
                foreach (ISellEDalerService Service in Services)
                {
                    if (!await Service.CanSellEDaler(AccountName))
                        continue;
 
                    Xml.Append("<provider id='");
                    Xml.Append(XML.Encode(Service.Id));
                    Xml.Append("' type='");
                    Xml.Append(XML.Encode(T.FullName));
                    Xml.Append("' name='");
                    Xml.Append(XML.Encode(Service.Name));
 
                    if (!string.IsNullOrEmpty(Service.IconUrl))
                    {
                        Xml.Append("' iconUrl='");
                        Xml.Append(XML.Encode(Service.IconUrl));
                        Xml.Append("' iconWidth='");
                        Xml.Append(Service.IconWidth.ToString());
                        Xml.Append("' iconHeight='");
                        Xml.Append(Service.IconHeight.ToString());
                    }
 
                    if (!string.IsNullOrEmpty(Service.SellEDalerTemplateContractId))
                    {
                        Xml.Append("' templateId='");
                        Xml.Append(XML.Encode(Service.SellEDalerTemplateContractId));
                    }
 
                    Xml.Append("'/>");
                }
            }
 
            Xml.Append("</providers>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private async Task InitiateGetOptionsSellEDalerHandler(object Sender, IqEventArgs e)
        {
            if (!this.Server.IsServerDomain(e.From.Domain, true) || !e.From.HasAccount)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            CaseInsensitiveString AccountName = e.From.Account;
            IAccount Account = await XmppServerModule.GetAccountAsync(AccountName);
            if (Account is null)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            if (!Account.Enabled)
            {
                await e.IqErrorForbidden(e.To, "Account has been disabled.", "en");
                return;
            }
 
            LegalIdentity Identity = await this.legal.GetCurrentApprovedLegalIdentityAsync(AccountName);
            if (Identity is null)
            {
                await e.IqErrorForbidden(e.To, "Account has no approved legal identity.", "en");
                return;
            }
 
            string Country = Identity[PersonalInformation.CountryTag];
            if (string.IsNullOrEmpty(Country))
            {
                await e.IqErrorForbidden(e.To, "Approved legal identity lacks country specified.", "en");
                return;
            }
 
            string ServiceId = XML.Attribute(e.Query, "serviceId");
            string ServiceProvider = XML.Attribute(e.Query, "serviceProvider");
            string SuccessUrl = XML.Attribute(e.Query, "successUrl");
            string FailureUrl = XML.Attribute(e.Query, "failureUrl");
            string CancelUrl = XML.Attribute(e.Query, "cancelUrl");
            string TransactionId = e.Query.HasAttribute("tid") ? XML.Attribute(e.Query, "tid") : Guid.NewGuid().ToString();
 
            if (string.IsNullOrEmpty(ServiceId))
            {
                await e.IqErrorBadRequest(e.To, "Service ID not defined.", "en");
                return;
            }
 
            if (string.IsNullOrEmpty(ServiceProvider))
            {
                await e.IqErrorBadRequest(e.To, "Service Provider not defined.", "en");
                return;
            }
 
            Type T = Types.GetType(ServiceProvider);
            if (T is null)
            {
                await e.IqErrorItemNotFound(e.To, "Service Provider " + ServiceProvider + " not found or installed.", "en");
                return;
            }
 
            if (!typeof(ISellEDalerServiceProvider).IsAssignableFrom(T) ||
                !(Types.Instantiate(T) is ISellEDalerServiceProvider SellEDalerServiceProvider))
            {
                await e.IqErrorBadRequest(e.To, "Service Provider does not support selling of eDaler.", "en");
                return;
            }
 
            Wallet Wallet = await this.GetWallet(AccountName, e.From.Domain);
            ISellEDalerService Service = await SellEDalerServiceProvider.GetServiceForSellingEDaler(ServiceId, Wallet.Currency, Country);
 
            if (Service is null)
            {
                await e.IqErrorItemNotFound(e.To, "Payment Service ID not found.", "en");
                return;
            }
 
            if (!await Service.CanSellEDaler(AccountName))
            {
                await e.IqErrorNotAllowed(e.To, "Selected service provider cannot perform action.", "en");
                return;
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<transaction xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("' tid='");
            Xml.Append(XML.Encode(TransactionId));
            Xml.Append("'/>");
 
            await e.IqResult(Xml.ToString(), e.To);
 
            Task _ = Task.Run(async () =>
            {
                try
                {
                    Dictionary<CaseInsensitiveString, CaseInsensitiveString> SellerIdParameters = new Dictionary<CaseInsensitiveString, CaseInsensitiveString>();
 
                    foreach (Property P in Identity.Properties)
                        SellerIdParameters[P.Name] = P.Value;
 
                    IDictionary<CaseInsensitiveString, object>[] Options;
 
                    try
                    {
                        Options = await Service.GetPaymentOptionsForSellingEDaler(SellerIdParameters,
                            SuccessUrl, FailureUrl, CancelUrl, async (sender, e2) =>
                            {
                                Xml.Clear();
 
                                Xml.Append("<sellEDalerOptionsClientUrl xmlns='");
                                Xml.Append(NamespaceEDaler);
                                Xml.Append("' tid='");
                                Xml.Append(XML.Encode(TransactionId));
                                Xml.Append("' url='");
                                Xml.Append(XML.Encode(e2.Url));
                                Xml.Append("'/>");
 
                                await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                                // Note: Client may have a new XMPP connection at this point.
                            }, null);
 
                        Xml.Clear();
 
                        Xml.Append("<sellEDalerOptionsCompleted xmlns='");
                        Xml.Append(NamespaceEDaler);
                        Xml.Append("' tid='");
                        Xml.Append(XML.Encode(TransactionId));
                        Xml.Append("'>");
 
                        if (!(Options is null))
                        {
                            foreach (IDictionary<CaseInsensitiveString, object> Option in Options)
                            {
                                Xml.Append("<option>");
 
                                foreach (KeyValuePair<CaseInsensitiveString, object> P in Option)
                                    StateMachineProcessor.AppendVariable(Xml, P.Key.Value, P.Value);
 
                                Xml.Append("</option>");
                            }
                        }
 
                        Xml.Append("</sellEDalerOptionsCompleted>");
 
                        await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                        // Note: Client may have displayed web URL and have a new XMPP connection at this point.
                    }
                    catch (Exception ex)
                    {
                        Xml.Clear();
 
                        Xml.Append("<sellEDalerOptionsError xmlns='");
                        Xml.Append(NamespaceEDaler);
                        Xml.Append("' tid='");
                        Xml.Append(XML.Encode(TransactionId));
                        Xml.Append("'>");
                        Xml.Append(XML.Encode(ex.Message));
                        Xml.Append("</sellEDalerOptionsError>");
 
                        await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                        // Note: Client may have displayed web URL and have a new XMPP connection at this point.
                    }
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
        }
 
        private async Task InitiateSellEDalerHandler(object Sender, IqEventArgs e)
        {
            if (!this.Server.IsServerDomain(e.From.Domain, true) || !e.From.HasAccount)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            CaseInsensitiveString AccountName = e.From.Account;
            IAccount Account = await XmppServerModule.GetAccountAsync(AccountName);
            if (Account is null)
            {
                await e.IqErrorForbidden(e.To, "Access to service providers only granted to accounts on broker.", "en");
                return;
            }
 
            if (!Account.Enabled)
            {
                await e.IqErrorForbidden(e.To, "Account has been disabled.", "en");
                return;
            }
 
            LegalIdentity Identity = await this.legal.GetCurrentApprovedLegalIdentityAsync(AccountName);
            if (Identity is null)
            {
                await e.IqErrorForbidden(e.To, "Account has no approved legal identity.", "en");
                return;
            }
 
            string Country = Identity[PersonalInformation.CountryTag];
            if (string.IsNullOrEmpty(Country))
            {
                await e.IqErrorForbidden(e.To, "Approved legal identity lacks country specified.", "en");
                return;
            }
 
            string ServiceId = XML.Attribute(e.Query, "serviceId");
            string ServiceProvider = XML.Attribute(e.Query, "serviceProvider");
            decimal Amount = XML.Attribute(e.Query, "amount", 0M);
            CaseInsensitiveString Currency = XML.Attribute(e.Query, "currency");
            string SuccessUrl = XML.Attribute(e.Query, "successUrl");
            string FailureUrl = XML.Attribute(e.Query, "failureUrl");
            string CancelUrl = XML.Attribute(e.Query, "cancelUrl");
            string TransactionId = e.Query.HasAttribute("tid") ? XML.Attribute(e.Query, "tid") : Guid.NewGuid().ToString();
 
            if (Amount <= 0)
            {
                await e.IqErrorBadRequest(e.To, "Invalid amount.", "en");
                return;
            }
 
            if (CaseInsensitiveString.IsNullOrEmpty(Currency))
            {
                await e.IqErrorBadRequest(e.To, "Invalid currency.", "en");
                return;
            }
 
            if (string.IsNullOrEmpty(ServiceId))
            {
                await e.IqErrorBadRequest(e.To, "Service ID not defined.", "en");
                return;
            }
 
            if (string.IsNullOrEmpty(ServiceProvider))
            {
                await e.IqErrorBadRequest(e.To, "Service Provider not defined.", "en");
                return;
            }
 
            Type T = Types.GetType(ServiceProvider);
            if (T is null)
            {
                await e.IqErrorItemNotFound(e.To, "Service Provider " + ServiceProvider + " not found or installed.", "en");
                return;
            }
 
            if (!typeof(ISellEDalerServiceProvider).IsAssignableFrom(T) ||
                !(Types.Instantiate(T) is ISellEDalerServiceProvider SellEDalerServiceProvider))
            {
                await e.IqErrorBadRequest(e.To, "Service Provider does not support selling of eDaler.", "en");
                return;
            }
 
            ISellEDalerService Service = await SellEDalerServiceProvider.GetServiceForSellingEDaler(ServiceId, Currency, Country);
 
            if (Service is null)
            {
                await e.IqErrorItemNotFound(e.To, "Payment Service ID not found.", "en");
                return;
            }
 
            if (!await Service.CanSellEDaler(AccountName))
            {
                await e.IqErrorNotAllowed(e.To, "Selected service provider cannot perform action.", "en");
                return;
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(Currency) && Service.Supports(Currency) == Grade.NotAtAll)
            {
                await e.IqErrorNotAllowed(e.To, "Selected service provider does not support selected currency (" + Currency + ").", "en");
                return;
            }
 
            if (!string.IsNullOrEmpty(Service.SellEDalerTemplateContractId))
            {
                await e.IqErrorForbidden(e.To, "Service provider requires a signed contract to perform payment. See associated Contract Template ID.", "en");
                return;
            }
 
            Dictionary<CaseInsensitiveString, object> ContractParameters = new Dictionary<CaseInsensitiveString, object>()
            {
                { "Amount", Amount },
                { "Currency", Currency.Value.ToUpper() }
            };
            Dictionary<CaseInsensitiveString, CaseInsensitiveString> SellerIdParameters = new Dictionary<CaseInsensitiveString, CaseInsensitiveString>();
 
            foreach (Property P in Identity.Properties)
                SellerIdParameters[P.Name] = P.Value;
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<transaction xmlns='");
            Xml.Append(NamespaceEDaler);
            Xml.Append("' tid='");
            Xml.Append(XML.Encode(TransactionId));
            Xml.Append("'/>");
 
            await e.IqResult(Xml.ToString(), e.To);
 
            Task _ = Task.Run(async () =>
            {
                try
                {
                    PaymentResult PaymentResult = await Paiwise.PaiwiseProcessor.SellEDaler(Amount, Currency, SuccessUrl,
                        FailureUrl, CancelUrl, Service, this, Identity.Id, null, ContractParameters, SellerIdParameters, TransactionId,
                        async (sender, e2) =>
                        {
                            Xml.Clear();
 
                            Xml.Append("<sellEDalerClientUrl xmlns='");
                            Xml.Append(NamespaceEDaler);
                            Xml.Append("' tid='");
                            Xml.Append(XML.Encode(TransactionId));
                            Xml.Append("' url='");
                            Xml.Append(XML.Encode(e2.Url));
                            Xml.Append("'/>");
 
                            await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                            // Note: Client may have a new XMPP connection at this point.
                        }, null);
 
                    if (PaymentResult.Ok)
                    {
                        Xml.Clear();
 
                        Xml.Append("<sellEDalerCompleted xmlns='");
                        Xml.Append(NamespaceEDaler);
                        Xml.Append("' tid='");
                        Xml.Append(XML.Encode(TransactionId));
                        Xml.Append("' amount='");
                        Xml.Append(CommonTypes.Encode(PaymentResult.Amount));
                        Xml.Append("' currency='");
                        Xml.Append(XML.Encode(PaymentResult.Currency));
                        Xml.Append("'/>");
 
                        await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                        // Note: Client may have displayed web URL and have a new XMPP connection at this point.
                    }
                    else
                    {
                        Xml.Clear();
 
                        Xml.Append("<sellEDalerError xmlns='");
                        Xml.Append(NamespaceEDaler);
                        Xml.Append("' tid='");
                        Xml.Append(XML.Encode(TransactionId));
                        Xml.Append("'>");
                        Xml.Append(XML.Encode(PaymentResult.Error));
                        Xml.Append("</sellEDalerError>");
 
                        await this.Server.SendMessage(string.Empty, string.Empty, e.To, e.From.ToBareJID(), string.Empty, Xml.ToString());
                        // Note: Client may have displayed web URL and have a new XMPP connection at this point.
                    }
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
        }
 
        /* TODO:
         * 
         * federated issue: Kolla edaler-komponent
         * Överföring: Krypterat meddelande
         * transactions over Neuro-Ledger
         * 
         * getTrustChain
         * getTransactions
         * 
         * Only accept eDaler from trusted domains
         * Only accept eDaler from endpoints with legal identities and proper sender signatures.
         * Only approved brokers can issue eDaler
         * Inform parent about created eDaler
         * 
         * Accounts & privileges
         * Godkända utgivare
         * Currency conversion
         * 
         * Manager settings
         *      max limit generate eDaler 
         *      
         * Require user to sign agreement before being able to use wallet.
         */
    }
}