LocalRecipient.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.Persistence.Exceptions;
using Waher.Runtime.Inventory;
using Waher.Runtime.Threading;
using Waher.Service.IoTBroker.EDaler.Uris;
using Waher.Service.IoTBroker.StateMachines;
 
namespace Waher.Service.IoTBroker.EDaler.Transactions
{
    public class LocalRecipient : EDalerTransaction
    {
        private Wallet wallet;
        private AccountEvent @event;
        private decimal amount = 0;
        private bool transferred = false;
        private DateTime prevTP = DateTime.MinValue;
        private ICurrencyConverterQuote quote = null;
        private Transaction transaction;
        private readonly bool addSecondaryTransactionObject;
 
        public LocalRecipient(EDalerUri Uri, bool AddSecondaryTransactionObject)
            : base(Uri)
        {
            this.addSecondaryTransactionObject = AddSecondaryTransactionObject;
        }
 
        protected override async Task<bool> DoPrepare()
        {
            this.wallet = await this.GetWallet(this.Uri.To, this.Uri.ToType);
 
            if (this.wallet is null)
            {
                this.Uri.State.Error(Uris.States.EDalerUriErrorType.ServiceUnavailable, "Recipient 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.Uri.Currency, this.wallet.Currency));
 
                if (Converter is null)
                {
                    this.Uri.State.Error(Uris.States.EDalerUriErrorType.Forbidden, "Recipient cannot receive 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, "Recipient cannot receive eDaler in " + this.Uri.Currency + ". Conversion not supported by service.", false);
                        return false;
                    }
                }
                catch (Exception ex)
                {
                    this.Uri.State.Error(Uris.States.EDalerUriErrorType.Forbidden, "Recipient cannot receive eDaler in " + this.Uri.Currency + ". Currency converter reports: " + ex.Message, false);
                    return false;
                }
 
                this.amount *= this.quote.Rate;
 
                // TODO: Commission
            }
 
            if (this.addSecondaryTransactionObject)
            {
                this.transaction = await Database.TryLoadObject<Transaction>(this.Uri.Id);
                if (!(this.transaction is null))
                {
                    this.Uri.State.Error(Uris.States.EDalerUriErrorType.ResourceConstraint, "eDaler transaction already processed.", false);
                    return false;
                }
            }
            else
                this.transaction = null;
 
            return true;
        }
 
        protected override async Task<bool> DoExecute()
        {
            using (Semaphore Semaphore = await Semaphores.BeginWrite("wallet:" + this.wallet.Account))
            {
                if (this.addSecondaryTransactionObject &&
                    (!string.IsNullOrEmpty(IoTGateway.Gateway.Domain) ||
                    (!CaseInsensitiveString.IsNullOrEmpty(this.Uri.State.Sender) &&
                    this.Uri.State.Sender != "example.com" &&
                    this.Uri.State.Sender != "example2.com" &&
                    this.Uri.State.Sender != "example3.com")))
                {
                    Transaction Transaction = new Transaction()
                    {
                        ObjectId = this.Uri.Id,
                        Created = this.Uri.Created,
                        Processed = DateTime.UtcNow,
                        From = this.Uri.From.Address,
                        FromType = this.Uri.FromType,
                        To = this.Uri.To.Address,
                        ToType = this.Uri.ToType,
                        Sender = this.Uri.State.Sender,
                        Amount = this.Uri.TotalAmount,
                        Currency = this.Uri.Currency,
                        Uri = this.Uri.UriString
                    };
 
                    try
                    {
                        await Database.Insert(Transaction);
                    }
                    catch (KeyAlreadyExistsException)
                    {
                        this.Uri.State.Error(Uris.States.EDalerUriErrorType.ResourceConstraint, "eDaler transaction already processed.", false);
                        return false;
                    }
                    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);
                        return false;
                    }
 
                    this.transaction = Transaction;
                }
 
                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.From.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()
        {
            CaseInsensitiveString Domain = this.wallet.Domain ?? this.Uri.EDaler.Server.Domain;
            XmppAddress To = new XmppAddress(this.wallet.Account + "@" + Domain);
 
            try
            {
                await StateMachineProcessor.EDalerReceived(To, this.Uri, this.Uri.State.OriginalSender);
            }
            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);
 
            KeyValuePair<string, object>[] Tags = new KeyValuePair<string, object>[]
            {
                new KeyValuePair<string, object>("Amount", this.Uri.TotalAmount),
                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)
            };
 
            LocalSender.Append(ref Tags, this.quote);
 
            Log.Notice(this.Uri.TotalAmount.ToString() + " " + this.Uri.Currency + 
                " eDaler received, and added to wallet.", this.wallet.Account,
                this.Uri.From.Address, "eDalerReceived", EventLevel.Major, Tags);
 
            return true;
        }
 
        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.Uri.TotalAmount),
                            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)
                        };
 
                        LocalSender.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.Uri.TotalAmount),
                            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)
                        };
 
                        LocalSender.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 (!(this.transaction is null))
            {
                await Database.Delete(this.transaction);
                this.transaction = null;
            }
 
            return Result;
        }
    }
}