private static PaymentEntity PreparePaymentEntityToSave(PaymentWriteModel paymentModel)
{
var paymentEntity = (PaymentEntity)paymentModel;
paymentEntity.PaymentDateTime = DateTime.Now;
return(paymentEntity);
}
private async Task ChargeUserAccountBalanceAsync(PaymentWriteModel paymentModel)
{
var user = await _userRepository.GetUserByIdAsync(paymentModel.UserId, false, false);
user.AccountBalance +=
paymentModel.Type == PaymentTypeEnum.Deposit
? Math.Round(paymentModel.Amount, 2)
: Math.Round(-paymentModel.Amount, 2);
}
private async Task CheckUserAccountBalanceBeforeWithdrawal(PaymentWriteModel paymentModel,
ICollection <ErrorViewModel> errors)
{
var canWithdraw = await CheckIsUserAbleToWithdrawAsync(paymentModel);
if (!canWithdraw)
{
errors.Add(ErrorViewModel.Factory.NewErrorFromMessage(_localizer["WithdrawalNotAffordableErrorMessage"]
.Value));
}
}
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 <ActionResult <PaymentViewModel> > CreatePaymentAsync([FromBody] PaymentWriteModel paymentModel)
{
try
{
var response = await _paymentService.CreatePaymentAsync(paymentModel);
return(response.StatusCode == StatusCodes.Status200OK
? Ok(response.Result)
: StatusCode(response.StatusCode, response.Errors));
}
catch (Exception ex)
{
_logger.LogError(ex, string.Empty);
return(StatusCode(StatusCodes.Status500InternalServerError,
ErrorViewModel.Factory.NewErrorFromException(ex)));
}
}
public async Task <ICollection <ErrorViewModel> > ValidatePaymentAsync(PaymentWriteModel paymentModel)
{
var errors = new List <ErrorViewModel>();
var doesUserExist = await CheckDoesTheUserExistAsync(paymentModel.UserId);
if (!doesUserExist)
{
errors.Add(ErrorViewModel.Factory.NewErrorFromMessage(_localizer["UserNotFoundErrorMessage",
paymentModel.UserId]
.Value));
return(errors);
}
if (paymentModel.Type == PaymentTypeEnum.Withdrawal)
{
await CheckUserAccountBalanceBeforeWithdrawal(paymentModel, errors);
}
return(errors);
}
public async Task <RequestResponseModel <PaymentViewModel> > CreatePaymentAsync(PaymentWriteModel paymentModel)
{
var errors = await _paymentValidator.ValidatePaymentAsync(paymentModel);
if (errors.Any())
{
return(new RequestResponseModel <PaymentViewModel>(StatusCodes.Status400BadRequest,
errors,
null));
}
var createdPayment = await SavePaymentAsync(paymentModel);
if (createdPayment == null)
{
return(new RequestResponseModel <PaymentViewModel>(StatusCodes.Status404NotFound,
new List <ErrorViewModel>
{
ErrorViewModel.Factory.NewErrorFromMessage(_localizer["PaymentNotCreatedErrorMessage"]
.Value)
}, null));
}
var result = (PaymentViewModel)createdPayment;
return(new RequestResponseModel <PaymentViewModel>(StatusCodes.Status200OK,
Enumerable.Empty <ErrorViewModel>(),
result));
}
private async Task <bool> CheckIsUserAbleToWithdrawAsync(PaymentWriteModel paymentModel)
{
var user = await _userRepository.GetUserByIdAsync(paymentModel.UserId, false, false);
return(user.AccountBalance >= paymentModel.Amount);
}
