Ejemplo n.º 1
0
 public async Task Handle(MoneyWithdrawnEvent message, IMessageHandlerContext context)
 {
     log.Info($"MoneyWithdrawnEvent, TransactionId = {message.TransactionId}");
     var command = new DepositMoneyCommand(
         Data.DestinationAccountId,
         Data.TransferId,
         Data.Amount
         );
     await context.Send(command).ConfigureAwait(false);
 }
        public async Task Handle(WithdrawMoneyCommand message, IMessageHandlerContext context)
        {
            log.Info($"WithdrawMoneyCommand, TransferId = {message.TransactionId}");
            var nhibernateSession = context.SynchronizedStorageSession.Session();
            var accountAggregate  = nhibernateSession.Get <Account>(message.AccountId);

            if (accountAggregate == null)
            {
                var sourceAccountNotFoundEvent = new SourceAccountNotFoundEvent(message.TransactionId);
                await context.Publish(sourceAccountNotFoundEvent);
            }
            else
            {
                if (accountAggregate.CanWithdrawMoney(message.Amount))
                {
                    accountAggregate.WithdrawMoney(message.Amount);
                    accountAggregate.ChangeUpdateAtUtc();
                    nhibernateSession.Save(accountAggregate);
                    var moneyWithdrawnEvent = new MoneyWithdrawnEvent
                                              (
                        message.AccountId,
                        message.TransactionId,
                        message.Amount,
                        accountAggregate.Balance.Amount,
                        accountAggregate.Sobregiro_disponible.Amount
                                              );
                    await context.Publish(moneyWithdrawnEvent);
                }
                else
                {
                    var withdrawMoneyRejectedEvent = new WithdrawMoneyRejectedEvent
                                                     (
                        message.TransactionId
                                                     );
                    await context.Publish(withdrawMoneyRejectedEvent);
                }
            }
        }
        public async Task Handle(WithdrawMoneyCommand message, IMessageHandlerContext context)
        {
            var nhibernateSession   = context.SynchronizedStorageSession.Session();
            var creditCardAggregate = nhibernateSession.Get <CreditCard>(message.CreditCardId);

            if (creditCardAggregate == null)
            {
                var sourceAccountNotFoundEvent = new SourceCreditCardNotFountEvent(message.PaymentId, message.OrderId);
                await context.Publish(sourceAccountNotFoundEvent);
            }
            else
            {
                if (creditCardAggregate.CanWithdrawMoney(message.Amount))
                {
                    creditCardAggregate.WithdrawMoney(message.Amount);
                    nhibernateSession.Save(creditCardAggregate);
                    var moneyWithdrawnEvent = new MoneyWithdrawnEvent
                                              (
                        message.CreditCardId,
                        message.PaymentId,
                        message.OrderId,
                        message.Amount,
                        creditCardAggregate.amountLimit.Amount
                                              );
                    await context.Publish(moneyWithdrawnEvent);
                }
                else
                {
                    var withdrawMoneyRejectedEvent = new WithdrawMoneyRejectedEvent
                                                     (
                        message.PaymentId,
                        message.OrderId
                                                     );
                    await context.Publish(withdrawMoneyRejectedEvent);
                }
            }
        }