/// <summary>
/// ExecuteAsync to execute and retrieve payment
/// </summary>
/// <param name="retrievePaymentRequest"></param>
/// <returns>Task<ActionResult<RetrievePaymentResponse>></returns>
public async Task <ActionResult <RetrievePaymentResponse> > ExecuteAsync(RetrievePaymentRequest retrievePaymentRequest)
{
var payment = await this._dataStoreDbContext.Payments
.Where(r => r.PaymentId == retrievePaymentRequest.PaymentId)
.FirstOrDefaultAsync <Payment>();
if (payment is null)
{
this._logger.LogWarning($@"RequestId:{this._requestTrackingService.RequestTraceId}
Payment details Not Found in DB for PaymentId:{retrievePaymentRequest.PaymentId}");
var errorResponse = new StandardErrorResponse
{
Type = HttpStatusCode.NotFound.ToString(),
RequestTraceId = this._requestTrackingService.RequestTraceId.ToString(),
Error = $"No Record found for PaymentId : {retrievePaymentRequest.PaymentId}"
};
return(new NotFoundObjectResult(errorResponse));
}
this._logger.LogDebug($@"RequestId:{this._requestTrackingService.RequestTraceId}
Payment details retrived from DataStore for PaymentId:{payment.PaymentId}");
var response = new RetrievePaymentResponse
{
PaymentId = payment.PaymentId,
CardNumber = payment.CardNumber,
Status = payment.PaymentStatus,
Expiry = payment.Expiry,
Amount = (decimal)payment.Amount,
Currency = payment.Currency
};
return(new OkObjectResult(response));
}
public async Task <ActionResult <ProcessPaymentResponse> > ProcessPaymentAsync(ProcessPaymentRequest paymentRequest)
{
var payment = new Payment(
paymentRequest.paymentRequestBody.Currency,
paymentRequest.paymentRequestBody.CVV,
paymentRequest.paymentRequestBody.Amount,
paymentRequest.paymentRequestBody.Expiry,
paymentRequest.paymentRequestBody.CardNumber
);
var validationHelper = new ValidationHelper();
if (!validationHelper.isValid(payment))
{
var errorResponse = new StandardErrorResponse
{
Type = HttpStatusCode.BadRequest.ToString(),
RequestTraceId = this._requestTrackingService.RequestTraceId.ToString(),
Error = $"Invalid Payment request : {JsonSerializer.Serialize(validationHelper.Error)}"
};
return(new BadRequestObjectResult(errorResponse));
}
return(await _payoutCommand.ExecuteAsync(payment));
}
/// <summary>
/// ExecuteAsync to execute and process payment
/// </summary>
/// <param name="payment"></param>
/// <returns>Task<ActionResult<ProcessPaymentResponse>></returns>
public async Task <ActionResult <ProcessPaymentResponse> > ExecuteAsync(Payment payment)
{
try
{
var bankResponse = await this._bank.PayOutAsync(payment);
if (bankResponse.PaymentStatus == Payment.Status.APPROVED)
{
payment.Approve(bankResponse.PaymentId);
}
if (bankResponse.PaymentStatus == Payment.Status.DECLINED)
{
payment.Decline(bankResponse.PaymentId);
}
using (var dbContext = this._dataStoreDbContext)
{
var createdPayment = dbContext.Payments.Add(payment);
await dbContext.SaveChangesAsync();
this._logger.LogDebug($@"RequestId:{this._requestTrackingService.RequestTraceId}
Payment stored in DB with PaymentId:{payment.PaymentId}");
}
return(new CreatedResult($"/api/payments/{payment.PaymentId}", new ProcessPaymentResponse {
PaymentId = payment.PaymentId
}));
}
catch (BankServiceException ex)
{
this._logger.LogError($@"RequestId:{this._requestTrackingService.RequestTraceId}
Bank Service Exception", ex);
//GENERATE StandardErrorResponse with request tracking id
var errorResponse = new StandardErrorResponse
{
Type = ex.GetType().ToString(),
Error = ex.Message,
RequestTraceId = this._requestTrackingService.RequestTraceId.ToString()
};
return(new ObjectResult(errorResponse)
{
StatusCode = (int)HttpStatusCode.ServiceUnavailable
});
}
}
protected virtual void LogBadRequest(StandardErrorResponse responseBody)
{
}
protected override void LogBadRequest(IOperation operation, StandardErrorResponse body)
{
Logged = true;
Debug.Assert(operation != null);
Debug.Assert(body != null);
}
protected override void LogBadRequest(string message, HttpActionContext context, StandardErrorResponse response)
{
Logged = true;
Debug.Assert(message != null);
Debug.Assert(context != null);
Debug.Assert(response != null);
}
protected virtual void LogBadRequest(string message, HttpActionContext context, StandardErrorResponse response)
{
}
protected virtual void LogBadRequest(IOperation operation, StandardErrorResponse body)
{
}
