EDalerPrimaryTransaction.cs

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.Security.LoginMonitor;
using Waher.Service.IoTBroker.EDaler.Uris;
using Waher.Service.IoTBroker.EDaler.Uris.States;
 
namespace Waher.Service.IoTBroker.EDaler.Transactions
{
    public abstract class EDalerPrimaryTransaction : EDalerTransaction
    {
        private Transaction transaction;
 
        public EDalerPrimaryTransaction(EDalerUri Uri)
            : base(Uri)
        {
        }
 
        protected override async Task<bool> DoPrepare()
        {
            this.transaction = await Database.TryLoadObject<Transaction>(this.Uri.Id);
            if (!(this.transaction is null))
            {
                this.Uri.State.Error(EDalerUriErrorType.ResourceConstraint, "eDaler transaction already processed.", false);
                return false;
            }
 
            return true;
        }
 
        protected override async Task<bool> DoExecute()
        {
            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.IsEmpty ? CaseInsensitiveString.Empty : this.Uri.To.Address,
                ToType = this.Uri.To.IsEmpty ? EntityType.NetworkJid : this.Uri.ToType,
                Sender = this.Uri.State.OriginalSender,
                Amount = this.Uri.TotalAmount,
                Currency = this.Uri.Currency,
                Uri = this.Uri.UriString
            };
 
            try
            {
                await Database.Insert(Transaction);
            }
            catch (KeyAlreadyExistsException)
            {
                this.Uri.State.Error(EDalerUriErrorType.ResourceConstraint, "eDaler transaction already processed.", false);
                return false;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
 
                this.Uri.State.Error(EDalerUriErrorType.ServiceUnavailable, "eDaler transaction could not be processed due to internal failure.", false);
                return false;
            }
 
            this.transaction = Transaction;
 
            return true;
        }
 
        protected override async Task<bool> DoCommit()
        {
            this.Uri.State.Result(this.transaction.ToXml());
 
            KeyValuePair<string, object>[] Tags = await LoginAuditor.Annotate(
                new XmppAddress(this.transaction.Sender).BareJid,
                new KeyValuePair<string, object>("Amount", this.transaction.Amount),
                new KeyValuePair<string, object>("Currency", this.transaction.Currency.Value),
                new KeyValuePair<string, object>("RefId", this.transaction.ObjectId.ToString()),
                new KeyValuePair<string, object>("Sender", this.transaction.Sender.Value),
                new KeyValuePair<string, object>("From", this.transaction.From.Value),
                new KeyValuePair<string, object>("To", this.transaction.To.Value),
                new KeyValuePair<string, object>("Uri", this.transaction.Uri));
 
            this.LogEvent(this.transaction.To, this.transaction.From,
                this.transaction.Amount, this.transaction.Currency, Tags);
 
            return true;
        }
 
        protected abstract void LogEvent(string To, string From, decimal Amount, string Currency,
            KeyValuePair<string, object>[] Tags);
 
        protected override async Task<bool> DoRollback()
        {
            if (!(this.transaction is null))
            {
                await Database.Delete(this.transaction);
                this.transaction = null;
            }
 
            return true;
        }
    }
}