public async Task Handle(CreatePaymentNotification notification, CancellationToken cancellationToken)
{
CustomerPayment customerPayment = new(notification.BasketCode, notification.Price, notification.PaidPrice, notification.CustomerCode,
notification.BasketItems, notification.ShippingAddress, notification.ShippingAddress, notification.SellerCode);
await _paymentRepository.AddAsync(customerPayment, cancellationToken);
}
public async Task ProcessPayment_ReturnsPayment()
{
//Arrange
var request = new ProcessPaymentRequest
{
Amount = 100,
Currency = "EUR",
FullName = "Dmitriy Purtseladze",
CardNumber = "5555-5555-5555-5555",
Cvv = 123,
Expiry = "08/22"
};
_bankService.ProcessPaymentAsync(request).Returns(new BankServiceResponse
{
IsSuccessHttpStatusCode = true,
HttpMessage = "success",
HttpStatusCode = HttpStatusCode.OK,
PaymentStatus = "success",
PaymentId = Guid.NewGuid().ToString()
});
const string encryptedCardNumber = "encrypted-card-number";
const string decryptedCardNumber = "5555-5555-5555-5555";
_aesHelper.Encrypt(decryptedCardNumber).Returns(encryptedCardNumber);
var maskedCardNumber = "xxxx-xxxx-xxxx-5555";
_creditCardMasker.MaskCreditCardNumber(Arg.Any <string>()).Returns(maskedCardNumber);
var payment = new Payment
{
Id = Guid.NewGuid(),
Amount = request.Amount,
Currency = request.Currency,
FullName = request.FullName,
CardNumber = encryptedCardNumber,
Expiry = request.Expiry
};
_paymentRepository.AddAsync(Arg.Any <Payment>()).Returns(payment);
var cmd = new ProcessPaymentCommand(request);
//Act
var response = await _subject.Handle(cmd);
//Assert
Assert.NotNull(response);
Assert.NotEqual(Guid.Empty, response.Id);
Assert.Equal(request.FullName, response.FullName);
Assert.Equal(request.Amount, response.Amount);
Assert.Equal(request.Currency, response.Currency);
Assert.Equal(maskedCardNumber, response.CardNumber);
Assert.Equal(request.Expiry, response.Expiry);
await _bankService.Received().ProcessPaymentAsync(request);
await _paymentRepository.Received().AddAsync(Arg.Any <Payment>());
}
public async Task HandleAsync(PayOrder command)
{
if (command == null)
{
throw new ServiceException(ErrorCodes.PustyRequest, "Post request add/payment is empty");
}
var order = await _orderRepository.GetAsync(command.Order.OrderID);
if (order == null)
{
throw new ServiceException(ErrorCodes.Nieznaleziono, $"Nie znaleziono zlecenia w bazie danych");
}
foreach (var teamID in command.Order.Teams)
{
var team = await _teamRepository.GetAsync(teamID.TeamID);
if (team == null)
{
throw new ServiceException(ErrorCodes.Nieznaleziono, $"Nie znaleziono zespołu w bazie danych");
}
var workers = (await _context.WorkerTeam.ToListAsync()).Where(x => x.TeamID == team.TeamID).ToList();
if (!workers.Any())
{
throw new ServiceException(ErrorCodes.Nieznaleziono, $"Nie znaleziono pracowników w bazie danych");
}
foreach (var ele in workers)
{
var worker = await _workerRepository.GetAsync(ele.WorkerID);
var days = DaysWithoutWeekends.Count(order.StartDate, (DateTime)order.EndDate);
var payment = new Payment
{
OrderID = command.Order.OrderID,
WorkerID = worker.WorkerID,
Amount = worker.ManHour * 8 * days,
PaymentDate = DateTime.UtcNow,
PaymentID = Guid.NewGuid()
};
await _paymentRepository.AddAsync(payment);
}
}
order.Paid = true;
await _orderRepository.UpdateAsync(order);
}
public async Task <long> Handle(CreatePaymentCommand request, CancellationToken cancellationToken)
{
var entity = new Payment
{
Name = request.Name,
IsComplete = false
};
entity.DomainEvents.Add(new PaymentCreatedEvent(entity));
await _repository.AddAsync(entity, cancellationToken);
return(entity.Id);
}
private async Task MeasureAndKeepResultAsync(IReadOnlyCollection <Payment> payments)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
await _objectUnderMeasurement.AddAsync(payments);
stopwatch.Stop();
await _objectUnderMeasurement.ClearAsync();
KeepResult(payments.Count, stopwatch.Elapsed);
}
public async Task <bool> Handle(CreatePaymentCommand request, CancellationToken cancellationToken)
{
// TODO: Use Distributed Transaction Like CAP, Saga, ...
var paymentCreatedEvent = _mapper.Map <PaymentCreatedEvent>(request);
var data = _mapper.Map <Domain.PaymentEntity>(paymentCreatedEvent);
data.Id = await _paymentRepository.AddAsync(data, CancellationToken.None);
paymentCreatedEvent.PaymentId = data.Id;
await _eventSourceRepository.InsertEventAsync(paymentCreatedEvent, cancellationToken);
_eventBus.Publish(paymentCreatedEvent);
return(true);
}
/// <summary>
/// save changes
/// </summary>
public async Task <PaymentModel> Create(PaymentModel model)
{
// try to add the payment model
await _repository.AddAsync(model);
await _repository.SaveChangesAsync();
// try to add the payment model
var result = _repository.GetByCreditCardAsync(model.CreditCardNumber);
if (result != null)
{
return(model);
}
// Throw the custom exception if unable to save the payment
throw new PaymentException("Unable to Save the Payment");
}
public async Task <Payment> AddPaymentAsync(CreateNewPayment newPaymentData)
{
newPaymentData.Validate();
var payer = await userRepository.GetByIdAsync(newPaymentData.PayerId);
if (payer == null)
{
throw new NotFoundException("User with given id does not exist.");
}
var receiver = await userRepository.GetByIdAsync(newPaymentData.ReceiverId);
if (receiver == null)
{
throw new NotFoundException("User with given id does not exist.");
}
var expectedPayments = await GetExpectedPaymentsBetweenUsers(
userA : payer,
userB : receiver,
groupContextId : newPaymentData.GroupContextId
);
if (expectedPayments.Count < 1)
{
throw new BadRequestException("No payment expected.");
}
var expectedPayment = expectedPayments.Single();
if (payer.Id != expectedPayment.PayerId || receiver.Id != expectedPayment.ReceiverId)
{
throw new BadRequestException($"User {receiver.Email} already owes you money.");
}
if (newPaymentData.Amount > expectedPayment.Amount)
{
throw new BadRequestException("Trying to pay back more than owned.");
}
var paymentToAdd = newPaymentData.ToPayment();
return(await paymentRepository.AddAsync(paymentToAdd));
}
public async Task <PaymentResponse> Handle(ProcessPaymentCommand command,
CancellationToken cancellationToken = default)
{
var bankResponse = await _bankService.ProcessPaymentAsync(command.Request);
var paymentToSave = _converter.Map <Payment>(command.Request);
paymentToSave.CardNumber = _aesHelper.Encrypt(paymentToSave.CardNumber);
paymentToSave.BankPaymentStatus = bankResponse.PaymentStatus;
paymentToSave.BankPaymentId = bankResponse.PaymentId;
var payment = await _paymentRepository.AddAsync(paymentToSave);
var paymentResponse = _converter.Map <PaymentResponse>(payment);
paymentResponse.CardNumber = _creditCardMasker.MaskCreditCardNumber(command.Request.CardNumber);
return(paymentResponse);
}
public async Task <string> AddAsync(Payments payment)
{
var resultFromPayment = _gateway.PaymentProcess(payment);
payment.PaymentStatus = PaymetStatus.Completed;
var paymentRef = await _context.AddAsync(payment);
//Publish the event here
//Create Integration Event
var paymentProcessedEvent = new PaymentProcessedIntegrationEvent(paymentRef.PaymentsId,
paymentRef.BookingOrderId,
paymentRef.CustomerId, (int)payment.PaymentStatus);
_eventBus.Publish(paymentProcessedEvent);
return(paymentRef.PaymentsId);
}
public async Task <OrderModel> AddAsync(List <OrderItemModel> items, Guid id)
{
var user = await _userService.GetAsync(id);
double totalCost = items.Sum(x => x.Count * x.PrintingEdition.Price);
if (totalCost <= default(int))
{
throw new ServerException(HttpStatusCode.BadRequest,
ExceptionMessage.INVALID_DATA);
}
var payment = new Payment()
{
TransactionId = string.Empty
};
var order = new OrderModel
{
UserId = user.Id,
CreationDate = DateTime.Now,
TotalCost = totalCost,
Status = Enums.OrderStatusType.Unpaid,
PaymentId = payment.Id,
Description = string.Empty
};
foreach (var item in items)
{
item.OrderId = order.Id;
}
order.Items = items;
var mapped = _mapper.Map <Order>(order);
await _paymentRepository.AddAsync(payment);
await _orderRepository.AddAsync(mapped);
return(order);
}
public override async Task <string> Execute(ConsumeContext <MakePayment> context)
{
var command = context.Message;
var response = await _processor.ProcessAsync(
command.Currency,
command.Amount,
command.CardNumber,
command.ExpiryMonth,
command.ExpiryYear,
command.Cvv,
command.CardHolderName);
// We assume command sent through the bus are ALWAYS valid. In other words, the code below should never fail.
var payment = Payment.Create(
response.PaymentId,
command.MerchantId,
Card.Create(
CardNumber.Create(command.CardNumber).GetValue(),
ExpiryDate.Create(command.ExpiryMonth, command.ExpiryYear).GetValue(),
Cvv.Create(command.Cvv).GetValue(),
command.CardHolderName).GetValue(),
Price.Create(command.Currency, command.Amount).GetValue(),
command.Description);
// This is simplistic :)
if (response.Status == PaymentStatus.Approved)
{
payment.Approve();
}
else
{
payment.Decline("Payment was declined");
}
// Persist the payment
await _repository.AddAsync(payment);
// We return the Id of the created entity!
return(response.PaymentId);
}
public async Task <PaymentModel> Create(PaymentModel model)
{
int retry = 3;
bool isFailed;
do
{
try
{
// try to add the payment model
await _repository.AddAsync(model);
await _repository.SaveChangesAsync();
// try to add the payment model
var result = _repository.GetByCreditCardAsync(model.CreditCardNumber);
if (result != null)
{
return(model);
}
// Throw the custom exception if unable to save the payment
throw new PaymentException("Unable to Save the Payment");
}
catch (PaymentException)
{
retry -= 1;
isFailed = true;
}
catch (Exception)
{
retry -= 1;
isFailed = true;
}
} while (retry != 0);
if (isFailed)
{
throw new PaymentException("Unable to Save the Payment");
}
return(model);
}
public async Task <PaymentResponse> SaveAsync(Payment payment, int userCommontId)
{
var existingUser = await _userCommonRepository.FindById(userCommontId);
if (existingUser == null)
{
return(new PaymentResponse("User not found"));
}
payment.UserCommon = existingUser;
try
{
await _paymentRepository.AddAsync(payment);
await _unitOfWork.CompleteAsync();
return(new PaymentResponse(payment));
}
catch (Exception ex)
{
return(new PaymentResponse($"An error ocurred while saving the payment: {ex.Message}"));
}
}
public async Task <Payment> AddPayment(PaymentDto payment)
{
try
{
var paymentEntity = _mapper.Map <PaymentDto, Payment>(payment);
paymentEntity = _paymentRepository.AddAsync(paymentEntity).Result;
PaymentState paymentStateData = new PaymentState()
{
Payment = paymentEntity, PaymentId = paymentEntity.PaymentId, CreatedDate = DateTime.Now, State = PaymentStateEnum.Pending.ToString()
};
var paymentState = await _paymentStateRepository.AddAsync(paymentStateData);
_UOW.Complete();
_paymentGateway.PaymentProcess(payment, paymentState);
return(paymentEntity);
}
catch (Exception)
{
throw new Exception("This payment can not be processed");
}
}
public async Task <string> AddAsync(PaymentDTO payment)
{
var resultFromPayment = _gateway.PaymentProcess(payment);
var paymentEntity = new Payments
{
BookingOrderId = payment.BookingOrderId,
CustomerId = payment.CustomerId,
Price = payment.Price,
PaymentStatus = PaymetStatus.Completed //This part is based on the result returned from external gateway
};
var paymentRef = await _context.AddAsync(paymentEntity);
//Publish the event here
//Create Integration Event
var paymentProcessedEvent = new PaymentProcessedIntegrationEvent(paymentRef.PaymentsId,
paymentRef.BookingOrderId,
paymentRef.CustomerId, (int)paymentEntity.PaymentStatus);
_eventBus.Publish(paymentProcessedEvent);
return(paymentRef.PaymentsId);
}
public async Task Handle(OrderPlacedEvent notification, CancellationToken cancellationToken)
{
Payment newPayment = new Payment(notification.OrderId);
await _paymentRepository.AddAsync(newPayment);
}
//Basic
public async Task <int> AddAsync(PaymentEntity paymentEntity)
{
return(await _paymentRepository.AddAsync(paymentEntity));
}
public async Task <Result> Handle(RegisterPayment request, CancellationToken cancellationToken)
{
var payment = Payment.Register(request.Id, request.SourceId, request.CategoryId, request.DateTime, request.Amount);
return(await paymentRepository.AddAsync(payment, cancellationToken));
}
