public async Task <IActionResult> DepositAsync(string accountId, [FromBody] decimal amount)
        {
            Contract.Requires(!String.IsNullOrEmpty(accountId));
            Contract.Requires(amount > 0.0m);
            if (String.IsNullOrEmpty(accountId))
            {
                return(BadRequest("Empty or null accountId is not allowed"));
            }
            if (amount <= 0.0m)
            {
                return(BadRequest("amount must be greater than zero"));
            }

            var command = new AccountDepositCommand(accountId, "Web");

            command.Amount = amount;

            var response = await _commandProcessor.ExecuteCommandAsync(command);

            if (response == null)
            {
                return(new RetryAfterResult(0.5m));
            }

            return(CreatedAtAction("GetTransactionDetailsAsync", "Transactions", new { transactionId = response.TransactionId }, response.TransactionId));
        }
Example #2
0
        public async Task <CreateTransactionResponse> ExecuteCommandAsync(AccountDepositCommand command)
        {
            if (command == null)
            {
                throw new ArgumentNullException(nameof(command));
            }

            var account = await _accountRepository.GetAccountAsync(command.AccountId);

            if (account == null)
            {
                throw new ResourceNotFoundException(
                          "Accounts", $"No account with id {command.AccountId} was found.");
            }

            var newTransaction =
                new Transaction(account, Transaction.DepositTransactionType, command.Amount);

            var saved = await _transactionRepository.AddNewTransactionAsync(newTransaction);

            if (saved == false)
            {
                throw new CommandProcessingException("Could not save transaction");
            }

            return(new CreateTransactionResponse(newTransaction.TransactionId));
        }
        public async Task <IActionResult> AccountDeposit([FromBody] DepositRequest request)
        {
            try
            {
                _logger.LogInformation("Received account deposit request.");

                //validate parameters
                if (request.AcctId == 0)
                {
                    _logger.LogInformation("Invalid account.");

                    return(new JsonResult(new DepositResponse()
                    {
                        StatusCode = Convert.ToInt32(HttpStatusCode.OK),
                        Message = Convert.ToString(HttpStatusCode.OK),
                        Payload = new DepositResponsePayload()
                        {
                            MessageDetail = "Invalid account."
                        }
                    }));
                }

                if (request.TransactionType != 3)
                {
                    _logger.LogInformation("Invalid transaction type.");

                    return(new JsonResult(new DepositResponse()
                    {
                        StatusCode = Convert.ToInt32(HttpStatusCode.OK),
                        Message = Convert.ToString(HttpStatusCode.OK),
                        Payload = new DepositResponsePayload()
                        {
                            MessageDetail = "Invalid transaction type."
                        }
                    }));
                }

                if (request.AmountDeposit == 0)
                {
                    _logger.LogInformation("No amount found to deposit.");

                    return(new JsonResult(new DepositResponse()
                    {
                        StatusCode = Convert.ToInt32(HttpStatusCode.OK),
                        Message = Convert.ToString(HttpStatusCode.OK),
                        Payload = new DepositResponsePayload()
                        {
                            MessageDetail = "No amount found to deposit."
                        }
                    }));
                }



                //call command handler
                var command       = new AccountDepositCommand(request.AcctId, request.TransactionType, request.AmountDeposit);
                var commandResult = await _mediator.Send(command);

                return(new JsonResult(new DepositResponse()
                {
                    StatusCode = commandResult.StatusCode,
                    Message = commandResult.Message,
                    Payload = new DepositResponsePayload()
                    {
                        MessageDetail = commandResult.MessageDetails,
                        TranId = commandResult.TranId
                    }
                }));
            }
            catch (Exception ex)
            {
                _logger.LogError("Account deposit request failed. Exception error message: {exceptionMessage}", ex.ToString());

                return(new JsonResult(new DepositResponse()
                {
                    StatusCode = Convert.ToInt32(HttpStatusCode.BadRequest),
                    Message = Convert.ToString(HttpStatusCode.BadRequest),
                    Payload = new DepositResponsePayload()
                    {
                        MessageDetail = "Account Deposit request failed. Exception Error: " + ex.ToString()
                    }
                }));
            }
        }