public static async Task AddPaymentsAsync(this IPaymentRepository paymentRepository, params Payment[] payments) { foreach (var payment in payments) { await paymentRepository.AddPaymentAsync(payment); } }
public async Task ShouldPassAddPayment() { _paymentRepository = new MockPaymentRepository(); var payment = new Payment { MerchantId = "bd2347d5-98b3-4d4e-8773-4eb4b33ca0d6", MerchantTransactionReference = "TestReference2", PaymentMethod = 0, Amount = 22.99M, Currency = Currency.GBP, PaymentDetails = new PaymentDetails { CardNumber = "1234567812345678", Name = "Test Name", ExpiryMonth = "12", ExpiryYear = "2030", CVV = "123", Scheme = CardScheme.Mastercard, Type = CardType.Credit, Address = new Address { Number = 1, Street = "Test Road", City = "Test City", County = "Test County", PostCode = "TE5 7PC" } } }; var result = await _paymentRepository.AddPaymentAsync(payment); Assert.IsTrue(result.PaymentDetails.Name == "Test Name"); }
public async Task <IActionResult> Post([FromBody] Payment payment) { try { _logger.LogInformation($"Post Payment Request - Merchant ID: {payment.MerchantId} + Payment Ref: {payment.MerchantTransactionReference}"); Merchant merchant = await _merchantRepository.GetMerchantAsync(payment.MerchantId); if (merchant == null) { _logger.LogWarning($"Merchant ({payment.MerchantId}) not found"); return(new BadRequestObjectResult("No Such Merchant Found")); } payment.MerchantId = merchant.Id; _logger.LogInformation("Attempting to connect to bank"); var bankResponse = await _bankProcessor.ProcessPaymentAsync(payment); _logger.LogInformation("Bank process complete"); Payment storedPayment = await _paymentRepository.AddPaymentAsync(bankResponse); _logger.LogInformation("Payment Processed"); return(new OkObjectResult(payment)); } catch (Exception e) { _logger.LogError(e.ToString()); return(new StatusCodeResult(500)); } }
public async Task Add_ShouldDelegateCallToRepository() { var payment = PaymentBuilder.Valid.Build(); await _sut.AddAsync(payment); A.CallTo(() => _paymentRepository.AddPaymentAsync(payment)).MustHaveHappened(1, Times.Exactly); }
public async Task GetUserBalanceList_WithPaymentFromUser_ShouldReturnPositiveBalance() { var payment = new PaymentBuilder("Eric").WithPaymentLine("Eric", 10).Build(); await _paymentRepository.AddPaymentAsync(payment); var result = (await _sut.GetUserBalanceList()).ToArray(); result.Should().HaveCount(5); result.Select(e => e.Balance).Should().AllBeEquivalentTo(0); }
public async Task <ActionResult <PaymentDto> > AddPayment([FromBody] Payment payment) { var query = await _repository.AddPaymentAsync(payment); if (query != null) { await _repository.CommitAsync(); } return(query.Entity.Adapt <PaymentDto>()); }
private async Task <PaymentEntity> SavePaymentAsync(PaymentWriteModel paymentModel) { var payment = PreparePaymentEntityToSave(paymentModel); await ChargeUserAccountBalanceAsync(paymentModel); var paymentEntity = await _paymentRepository.AddPaymentAsync(payment); await _paymentRepository.SaveChangesAsync(); return(paymentEntity); }
public async Task <IActionResult> InsertPaymentAsync([FromBody] Payment payment) { try { return(StatusCode(StatusCodes.Status200OK, await _payment.AddPaymentAsync(payment))); } catch (Exception ex) { _logger.LogError(ex.Message); _logger.LogError(ex.StackTrace); return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message)); } }
public async Task AddPayment_ShouldAddPayment() { var payment = new PaymentBuilder("TestUser") .WithDescription("TestExpense") .WithPaymentLine("TestUser", 10.5m) .Build(); await _paymentRepository.AddPaymentAsync(payment); var fetchedPayment = (await _paymentRepository.FindPaymentsPayedBy("TestUser")).Single(); fetchedPayment.Should().BeEquivalentTo(payment); }
public async Task <Payment> CreateCardPaymentAsync(Guid merchantId, CardPaymentRequestDto requestDto) { //Depending on the card payment we may want to route to different acquirers //in this example we only have bankOfIreland but in future we can add more here var acquirerBankToUse = _acquirerBankSelectionService.GetAcquirerBankToUse(requestDto); var payment = await _paymentRepository.AddPaymentAsync(acquirerBankToUse, merchantId, requestDto); switch (acquirerBankToUse) { case AcquirerBank.BankOfIreland: return(await _bankOfIrelandAcquiringBankService.CreatePaymentAsync(merchantId : merchantId, paymentId : payment.PaymentId, requestDto)); default: throw new ArgumentException($"Unable able to support AcquirerBank {acquirerBankToUse}"); } }
public async Task <IActionResult> Post([FromBody] PostPaymentRequest request) { if (!ModelState.IsValid) { return(BadRequest()); } var paymentId = Guid.NewGuid(); try { var payment = _mapper.Map <Payment>(request); payment.Id = paymentId; payment.CardNumber = _encryptionService.Encrypt(request.CardNumber); var bankRequest = _mapper.Map <BankRequest>(request); await _paymentRepository.AddPaymentAsync(payment); _logger.LogInformation($"POST - Starting request to bank for payment {payment.Id}"); var bankResponse = await _bankRequestService.PostBankRequestAsync(bankRequest); payment.BankResponseId = bankResponse.Id; payment.PaymentStatus = bankResponse.PaymentStatus; await _paymentRepository.UpdatePaymentAsync(payment); var postPaymentResponse = new PostPaymentResponse { PaymentId = payment.Id }; return(Ok(postPaymentResponse)); } catch (Exception ex) { _logger.LogError($"POST - Failed due to exception ${ex.GetType()} with error ${ex.Message} for request ${paymentId}"); return(StatusCode(500)); } }
public async Task <ActionResult <OrderModel> > PayForOrderAsync(int orderId, UserDetailsModel userDetails) { try { _logger.LogInformation("{Username} has started payment for the order with OrderId {OrderId}.", userDetails.Username, orderId); if (userDetails.CardAuthorizationInfo.ToLower() != "authorized" && userDetails.CardAuthorizationInfo.ToLower() != "unauthorized") { throw new ArgumentException("CardAuthorizationInfo is not valid."); } var orderRequestDto = new OrderRequestDto { OrderId = orderId }; _rpcClient.Open(); var order = _rpcClient.Call(orderRequestDto); _rpcClient.Close(); if (order.OrderId == 0) { throw new ArgumentException("No order with such id."); } if (userDetails.Username != order.Username) { throw new ArgumentException("Usernames in order and user details should be equal."); } if (order.Status.ToLower() != "collecting") { throw new InvalidOperationException("Order status should be \"Collecting\"."); } switch (userDetails.CardAuthorizationInfo.ToLower()) { case "authorized": order.PaymentId = DateTime.Now.Ticks; order.Status = "Paid"; break; case "unauthorized": order.PaymentId = DateTime.Now.Ticks; order.Status = "Failed"; break; } var payment = new Payment { PaymentId = order.PaymentId.Value, OrderId = order.OrderId, Username = order.Username, TotalCost = order.TotalCost, IsPassed = order.Status == "Paid" ? true : false }; await _paymentRepository.AddPaymentAsync(payment); var payForOrderDto = _mapper.Map <PayForOrderDto>(order); _rabbitManager.Publish(payForOrderDto, "PaymentService_OrderExchange", ExchangeType.Direct, "PayForOrder"); _logger.LogInformation("{Username} has finished payment for the order with OrderId {OrderId} with status {Status}.", order.Username, order.OrderId, order.Status); return(order); } catch (TimeoutException e) { _logger.LogInformation("{Username} has failed to perform payment for the order with OrderId {OrderId}.", userDetails.Username, orderId); return(StatusCode(408, e.Message)); } catch (Exception e) { _logger.LogInformation("{Username} has failed to perform payment for the order with OrderId {OrderId}.", userDetails.Username, orderId); return(BadRequest(e.Message)); } }
public async Task AddAsync(Payment payment) { (await CreateValidator.ValidateAsync(payment)).ThrowIfInvalid(); await _paymentRepository.AddPaymentAsync(payment); }