public async Task <List <TransactionResponseVm> > Handle(GetTransactionByMerchantId request, CancellationToken cancellationToken)
        {
            var response = new List <TransactionResponseVm>();

            try
            {
                var transactionItems = await _transactionsService.GetByMerchantIdAsync(request.MerchantId);

                return(transactionItems?.Select(transactionItem =>
                                                new TransactionResponseVm(
                                                    transactionId: transactionItem.Id,
                                                    merchantId: transactionItem.MerchantId,
                                                    cardHolderName: transactionItem.CardHolderName,
                                                    cardNumber: _cardsService.Decrypt(transactionItem.CardNumber).Mask('X'),
                                                    amount: transactionItem.Amount,
                                                    statusCode: transactionItem.StatusCode,
                                                    description: transactionItem.Description,
                                                    timestamp: transactionItem.Timestamp)).ToList() ?? response);
            }
            catch (Exception ex)
            {
                _logger.LogError(
                    ex,
                    "Checkout Request: Unhandled Exception for Request {Name} {@Request}",
                    nameof(GetTransactionById),
                    request);
            }

            return(response);
        }
Exemplo n.º 2
0
        public async Task <TransactionResponseVm> Handle(GetTransactionById request, CancellationToken cancellationToken)
        {
            try
            {
                var result = await _transactionsHistoryService.GetByTransactionIdAsync(request.Id);

                return(result != null ?
                       new TransactionResponseVm(
                           transactionId: result.Id,
                           merchantId: result.MerchantId,
                           cardHolderName: result.CardHolderName,
                           cardNumber: _cardsService.Decrypt(result.CardNumber).Mask('X'),
                           amount: result.Amount,
                           statusCode: result.StatusCode,
                           description: result.Description,
                           timestamp: result.Timestamp) :
                       new TransactionResponseVm(
                           transactionId: request.Id,
                           merchantId: Guid.Empty,
                           cardHolderName: string.Empty,
                           cardNumber: string.Empty,
                           amount: 0,
                           statusCode: HttpStatusCode.NotFound.ToString(),
                           description: "The requested transaction could not be found",
                           timestamp: DateTime.MinValue));
            }
            catch (Exception ex)
            {
                _logger.LogError(
                    ex,
                    "Checkout Request: Unhandled Exception for Request {Name} {@Request}",
                    nameof(GetTransactionById),
                    request);
            }

            return(new TransactionResponseVm(
                       transactionId: request.Id,
                       merchantId: Guid.Empty,
                       cardHolderName: string.Empty,
                       cardNumber: string.Empty,
                       amount: 0,
                       statusCode: HttpStatusCode.ServiceUnavailable.ToString(),
                       description: "Unfortunately It was not possible to process your request",
                       timestamp: DateTime.MinValue));
        }