LocalSender.cs

using Paiwise;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Runtime.Inventory;
using Waher.Runtime.Threading;
using Waher.Service.IoTBroker.EDaler.Uris;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Identity;
using Waher.Service.IoTBroker.StateMachines;
 
namespace Waher.Service.IoTBroker.EDaler.Transactions
{
    public class LocalSender : EDalerPrimaryTransaction
    {
        private Wallet wallet;
        private AccountEvent @event;
        private decimal amount = 0;
        private bool transferred = false;
        private DateTime prevTP = DateTime.MinValue;
        private ICurrencyConverterQuote quote = null;
        private readonly bool validateSenderSignature;
 
        public LocalSender(EDalerUri Uri, bool ValidateSenderSignature)
            : base(Uri)
        {
            this.validateSenderSignature = ValidateSenderSignature;
        }
 
        protected override async Task<bool> DoPrepare()
        {
            if (this.validateSenderSignature)
            {
                LegalIdentity Signer = null;
 
                switch (this.Uri.FromType)
                {
                    case EntityType.NetworkJid:
                        (Signer, _) = await this.Uri.EDaler.Legal.ValidateSenderSignature(
                            this.Uri.From, this.Uri.State, this.Uri.Created,
                            this.Uri.PreSign, this.Uri.Signature, null);
                        break;
 
                    case EntityType.LegalId:
                        LegalIdentity Temp = await LegalComponent.GetLocalLegalIdentity(this.Uri.From.BareJid);
                        if (Temp is null)
                            break;
 
                        XmppAddress TempAddress = new XmppAddress(Temp.Id);
                        int i = TempAddress.Domain.IndexOf('.');
                        string JidDomain = i < 0 ? this.Uri.EDaler.Server.Domain : TempAddress.Domain.Substring(i + 1);
 
                        (Signer, _) = await this.Uri.EDaler.Legal.ValidateSenderSignature(
                            new XmppAddress(Temp.Account + "@" + JidDomain),
                            this.Uri.State, this.Uri.Created, this.Uri.PreSign, this.Uri.Signature, null);
 
                        if (Signer is null)
                            return false;
 
                        if (Signer.Id != Temp.Id)
                            Signer = null;
                        break;
                }
 
                if (Signer is null)
                {
                    this.Uri.State.Error(Uris.States.EDalerUriErrorType.BadRequest, "Invalid sender signature.", false);
                    return false;
                }
            }
 
            if (!await base.DoPrepare())
                return false;
 
            this.wallet = await this.GetWallet(this.Uri.From, this.Uri.FromType);
 
            if (this.wallet is null)
            {
                this.Uri.State.Error(Uris.States.EDalerUriErrorType.ServiceUnavailable, "Sender wallet not found.", false);
                return false;
            }
 
            this.amount = this.Uri.TotalAmount;
 
            if (this.Uri.Currency != this.wallet.Currency)
            {
                ICurrencyConverterService Converter = Types.FindBest<ICurrencyConverterService, CurrencyPair>(
                    new CurrencyPair(this.wallet.Currency, this.Uri.Currency));
 
                if (Converter is null)
                {
                    this.Uri.State.Error(Uris.States.EDalerUriErrorType.Forbidden, "Sender cannot send eDaler in " + this.Uri.Currency + ". No currency conversion service available.", false);
                    return false;
                }
 
                try
                {
                    this.quote = await Converter.GetCurrencyConversionQuote(this.wallet.Currency, this.Uri.Currency);
                    if (this.quote is null)
                    {
                        this.Uri.State.Error(Uris.States.EDalerUriErrorType.Forbidden, "Sender cannot send eDaler in " + this.Uri.Currency + ". Conversion not supported by service.", false);
                        return false;
                    }
                }
                catch (Exception ex)
                {
                    this.Uri.State.Error(Uris.States.EDalerUriErrorType.Forbidden, "Sender cannot send eDaler in " + this.Uri.Currency + ". Currency converter reports: " + ex.Message, false);
                    return false;
                }
 
                this.amount *= this.quote.Rate;
 
                // TODO: Commission
            }
 
            if (this.wallet.Balance < this.amount)
            {
                this.Uri.State.Error(Uris.States.EDalerUriErrorType.Forbidden, "Sender lacks funds to perform transaction.", false);
                return false;
            }
 
            return true;
        }
 
        protected override async Task<bool> DoExecute()
        {
            using (Semaphore Semaphore = await Semaphores.BeginWrite("wallet:" + this.wallet.Account))
            {
                if (this.wallet.Balance < this.amount)
                {
                    this.Uri.State.Error(Uris.States.EDalerUriErrorType.Forbidden, "Sender lacks funds to perform transaction.", false);
                    return false;
                }
 
                if (!await base.DoExecute())
                    return false;
 
                AccountEvent Ref = null;
                DateTime BakTP = this.wallet.BalanceTimestamp;
                decimal Bak = this.wallet.Balance;
                bool RefAdded = false;
 
                try
                {
                    Ref = new AccountEvent()
                    {
                        TransactionId = this.Uri.Id,
                        Timestamp = DateTime.UtcNow,
                        Account = this.wallet.Account,
                        Remote = this.Uri.To.Address,
                        Change = -this.amount,
                        Balance = this.wallet.Balance - this.amount,
                        Reserved = this.wallet.Reserved,
                        EncryptedMessage = this.Uri.EncryptedMessage,
                        EncryptionPublicKey = this.Uri.EncryptionPublicKey
                    };
 
                    await Database.Insert(Ref);
                    RefAdded = true;
 
                    this.prevTP = this.wallet.BalanceTimestamp;
 
                    this.wallet.Balance -= this.amount;
                    this.wallet.BalanceTimestamp = Ref.Timestamp;
 
                    await Database.Update(this.wallet);
 
                    this.transferred = true;
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
 
                    this.Uri.State.Error(Uris.States.EDalerUriErrorType.ServiceUnavailable, "eDaler transaction could not be processed due to internal failure.", false);
 
                    this.wallet.Balance = Bak;
                    this.wallet.BalanceTimestamp = BakTP;
                    this.transferred = false;
 
                    if (RefAdded)
                    {
                        try
                        {
                            await Database.Delete(Ref);
                        }
                        catch (Exception ex2)
                        {
                            Log.Exception(ex2);
                        }
                    }
 
                    return false;
                }
 
                this.@event = Ref;
            }
 
            return true;
        }
 
        protected override async Task<bool> DoCommit()
        {
            if (!await base.DoCommit())
                return false;
 
            CaseInsensitiveString Domain = this.wallet.Domain ?? this.Uri.EDaler.Server.Domain;
            XmppAddress To = new XmppAddress(this.wallet.Account + "@" + Domain);
 
            try
            {
                await StateMachineProcessor.EDalerSent(To, this.Uri);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
 
            string Xml = await this.Uri.EDaler.GetWalletBalanceXml(this.wallet.Account, Domain, this.@event);
 
            await this.Uri.EDaler.Server.SendMessage(string.Empty, string.Empty,
                new XmppAddress(this.Uri.EDaler.Subdomain + "." + Domain), To, string.Empty, Xml);
 
            return true;
        }
 
        protected override void LogEvent(string To, string From, decimal Amount, string Currency,
            KeyValuePair<string, object>[] Tags)
        {
            Append(ref Tags, this.quote);
 
            Log.Notice(Amount.ToString() + " " + Currency + " eDaler transmitted, and removed from wallet.", 
                To, From, "eDalerTransmitted", EventLevel.Major, Tags);
        }
 
        internal static void Append(ref KeyValuePair<string, object>[] Tags, ICurrencyConverterQuote Quote)
        {
            if (!(Quote is null))
            {
                int c = Tags.Length;
                Array.Resize(ref Tags, c + 5);
                Tags[c] = new KeyValuePair<string, object>("ExchangeFrom", Quote.FromCurrency);
                Tags[c + 1] = new KeyValuePair<string, object>("ExchangeTo", Quote.ToCurrency);
                Tags[c + 2] = new KeyValuePair<string, object>("ExchangeRate", Quote.Rate);
                Tags[c + 3] = new KeyValuePair<string, object>("Timestamp", Quote.Timestamp);
                Tags[c + 4] = new KeyValuePair<string, object>("Source", Quote.Source);
            }
        }
 
        protected override async Task<bool> DoRollback()
        {
            bool Result = true;
 
            using (Semaphore Semaphore = await Semaphores.BeginWrite("wallet:" + this.wallet.Account))
            {
                if (this.amount != 0 && this.transferred)
                {
                    DateTime BakTP = this.wallet.BalanceTimestamp;
                    decimal Bak = this.wallet.Balance;
 
                    try
                    {
                        this.wallet.Balance += this.amount;
 
                        if (this.wallet.BalanceTimestamp == this.@event.Timestamp)
                            this.wallet.BalanceTimestamp = this.prevTP;
 
                        await Database.Update(this.wallet);
                        this.amount = 0;
                        this.transferred = false;
                    }
                    catch (Exception ex)
                    {
                        Result = false;
 
                        this.wallet.Balance = Bak;
                        this.wallet.BalanceTimestamp = BakTP;
 
                        KeyValuePair<string, object>[] Tags = new KeyValuePair<string, object>[]
                        {
                            new KeyValuePair<string, object>("Amount", -this.amount),
                            new KeyValuePair<string, object>("Currency", this.Uri.Currency),
                            new KeyValuePair<string, object>("RefId", this.Uri.Id.ToString()),
                            new KeyValuePair<string, object>("Sender", this.Uri.State.Sender.Value),
                            new KeyValuePair<string, object>("From", this.Uri.From.Address.Value),
                            new KeyValuePair<string, object>("To", this.Uri.To.Address.Value),
                            new KeyValuePair<string, object>("Uri", this.Uri.UriString)
                        };
 
                        Append(ref Tags, this.quote);
 
                        Log.Error("Unable to rollback wallet change of " + (-this.amount).ToString() +
                            " for " + this.wallet.Account + ". Error reported:\r\n\r\n" + ex.Message,
                            this.wallet.Account, string.Empty, "eDalerError", Tags);
                    }
                }
 
                if (!(this.@event is null))
                {
                    try
                    {
                        await Database.Delete(this.@event);
                        this.@event = null;
                    }
                    catch (Exception ex)
                    {
                        Result = false;
 
                        KeyValuePair<string, object>[] Tags = new KeyValuePair<string, object>[]
                        {
                            new KeyValuePair<string, object>("Amount", -this.amount),
                            new KeyValuePair<string, object>("Currency", this.Uri.Currency),
                            new KeyValuePair<string, object>("RefId", this.Uri.Id.ToString()),
                            new KeyValuePair<string, object>("Sender", this.Uri.State.Sender.Value),
                            new KeyValuePair<string, object>("From", this.Uri.From.Address.Value),
                            new KeyValuePair<string, object>("To", this.Uri.To.Address.Value),
                            new KeyValuePair<string, object>("Uri", this.Uri.UriString)
                        };
 
                        Append(ref Tags, this.quote);
 
                        Log.Error("Unable to rollback wallet event of " + (-this.amount).ToString() +
                            " for " + this.wallet.Account + ". Error reported:\r\n\r\n" + ex.Message,
                            this.wallet.Account, string.Empty, "eDalerError", Tags);
                    }
                }
 
                if (!await base.DoRollback())
                    Result = false;
            }
 
            return Result;
        }
    }
}