public CardPaymentResponse DoPayment(CardPaymentRequest request)
        {
            var paymentStatus = _paymentRepository.GetPaymentStatus(request.RequestId);

            if (paymentStatus != null)
            {
                throw new RequestAlreadyProcessedException(paymentStatus.Status, paymentStatus.RequestId);
            }
            var currentPaymentStatus = new PaymentStatus()
            {
                RequestId = request.RequestId, Status = PaymentStatusEnum.Scheduled
            };

            _paymentRepository.AddPaymentStatus(currentPaymentStatus);

            var cards = _cardRepository.GetAllCards();

            if (!cards.Contains(request.GetCard()))
            {
                return new CardPaymentResponse {
                           TransactionStatus = TransactionStatus.Declined, Message = "Wrong card details", RequestId = request.RequestId
                }
            }
            ;

            var bankAccounts = _bankAccountRepository.GetAllBankAccounts();

            if (!bankAccounts.Contains(request.GetBankAccount()))
            {
                return new CardPaymentResponse {
                           TransactionStatus = TransactionStatus.Declined, Message = "Wrong bank account details", RequestId = request.RequestId
                }
            }
            ;


            try
            {
                // here the bank performs the transaction
                currentPaymentStatus.TransactionId = Guid.NewGuid().ToString();

                // transaction ok

                currentPaymentStatus.Status = PaymentStatusEnum.Completed;
                _paymentRepository.UpdatePaymentStatus(currentPaymentStatus);
            }
            catch (Exception e)
            {
                currentPaymentStatus.Status = PaymentStatusEnum.Error;
                _paymentRepository.UpdatePaymentStatus(currentPaymentStatus);
                throw;
            }
            // return the status
            return(new CardPaymentResponse {
                TransactionStatus = TransactionStatus.Succeeded, RequestId = request.RequestId, TransactionId = currentPaymentStatus.TransactionId
            });
        }
    }
}
Exemple #2
0
        public async Task <CreatePaymentResponse> CreatePayment(Payment payment)
        {
            // verify if the payment request exists already
            var paymentStatus = await _paymentRepository.GetPaymentStatus(payment.RequestId);

            if (paymentStatus != null)
            {
                return new CreatePaymentResponse {
                           ErrorCode = Consts.DUPLICATE_REQUEST_CODE
                }
            }
            ;


            paymentStatus = new PaymentStatus()
            {
                PaymentId = Guid.NewGuid(), RequestId = payment.RequestId, Status = PaymentStatusEnum.Scheduled
            };
            await _paymentRepository.AddPaymentStatus(paymentStatus);

            try
            {
                // get the merchant and check
                var merchant = await _merchantRepository.GetMerchantById(payment.MerchantId);

                if (merchant == null)
                {
                    return new CreatePaymentResponse {
                               ErrorCode = Consts.MERCHANT_NOT_PRESENT_CODE
                    }
                }
                ;
                if (!merchant.IsValid)
                {
                    return new CreatePaymentResponse {
                               ErrorCode = Consts.MERCHANT_INVALID_CODE
                    }
                }
                ;

                // Prepare the full payment data to send to the Event Broker

                var paymentRequestMessage = createPaymentRequestMessage(payment, merchant);
                paymentRequestMessage.PaymentRequestId = paymentStatus.PaymentId;

                var encryptedMessage = new EncryptedMessage(EventBrokerConsts.PAYMENT_REQUEST_EXCHANGE_NAME, EventBrokerConsts.PAYMENT_REQUEST_ROUTINGKEY, "PaymentGateway.Api", paymentRequestMessage, _cipherService);
                _eventBrokerPublisher.PublishEncryptedMessage(encryptedMessage);

                // set the payment status
                paymentStatus.Status = PaymentStatusEnum.Completed;
                await _paymentRepository.UpdatePaymentStatus(paymentStatus);

                // create the response
                return(new CreatePaymentResponse()
                {
                    RequestId = payment.RequestId, PaymentRequestId = paymentStatus.PaymentId
                });
            }
            catch (Exception e)
            {
                var errorReferenceGuid = Guid.NewGuid();
                _logger.LogError($"ReferenceId:{errorReferenceGuid}, Error Message:{e.Message}");
                paymentStatus.Status = PaymentStatusEnum.Error;
                await _paymentRepository.UpdatePaymentStatus(paymentStatus);

                return(new CreatePaymentResponse {
                    ErrorCode = Consts.UNEXPECTED_ERROR_CODE, ErrorReferencegGuid = errorReferenceGuid
                });
            }
        }