public async Task <ActionResult> Create([FromBody] CreatePaymentRequestModel requestModel)
{
if (!EnsureMerchantValidity(out var merchant))
{
return(BadRequest(new ErrorResponseModel("missing or invalid merchant header")));
}
var creditCardInformation = new CreditCardInformation(requestModel.CreditCardNumber,
new ExpiryDate(requestModel.CreditCardExpiryMonth, requestModel.CreditCardExpiryYear),
requestModel.CreditCardCcv);
var paymentAmount = new PaymentAmount(requestModel.Amount, requestModel.CurrencyCode);
var payment = Payment.Create(paymentAmount, creditCardInformation, merchant.MerchantId, requestModel.ExternalShopperIdentifier);
bool wasPaymentSuccessful = await payment.AttemptPayment(merchant.CreditCardInformation, _bankConnectorDS);
_paymentRepository.Add(payment);
await _paymentRepository.PersistAsync();
_logger.LogInformation($"New payment was created with PaymentId: {payment.PaymentId}");
var responseModel = new CreatePaymentResponseModel
{
WasPaymentSuccessful = wasPaymentSuccessful,
PaymentId = payment.PaymentId
};
return(Accepted(responseModel));
}
public async Task <IActionResult> CreateAsync([FromBody] CreatePaymentRequestModel model)
{
try
{
IReadOnlyList <string> settlementAssets =
await _assetSettingsService.ResolveSettlementAsync(model.MerchantId);
if (!settlementAssets.Contains(model.SettlementAssetId))
{
return(BadRequest(new PaymentRequestErrorModel
{
Code = CreatePaymentRequestErrorType.SettlementAssetNotAvailable
}));
}
IReadOnlyList <string> paymentAssets =
await _assetSettingsService.ResolvePaymentAsync(model.MerchantId, model.SettlementAssetId);
if (!paymentAssets.Contains(model.PaymentAssetId))
{
return(BadRequest(new PaymentRequestErrorModel
{
Code = CreatePaymentRequestErrorType.PaymentAssetNotAvailable
}));
}
var paymentRequest = Mapper.Map <PaymentRequest>(model);
IPaymentRequest createdPaymentRequest = await _paymentRequestService.CreateAsync(paymentRequest);
return(Ok(Mapper.Map <PaymentRequestModel>(createdPaymentRequest)));
}
catch (AssetUnknownException e)
{
_log.Error(e, e.Message, e.Asset);
return(BadRequest(new PaymentRequestErrorModel
{
Code = CreatePaymentRequestErrorType.RequestValidationCommonError
}));
}
catch (AssetNetworkNotDefinedException e)
{
_log.Error(e, e.Message, e.AssetId);
return(BadRequest(new PaymentRequestErrorModel
{
Code = CreatePaymentRequestErrorType.RequestValidationCommonError
}));
}
}
public IActionResult CreatePaymentRequest([FromBody] CreatePaymentRequestModel requestModel)
{
//Generate the instamojo payment request id, udate the instamojo log collection, return the redirect url
try
{
var result = helper.CreatePaymentRequest(requestModel.username, requestModel.amount, requestModel.responseurl);
if (result != null && !string.IsNullOrEmpty(result.AbsoluteUri))
{
return(Ok(result.AbsoluteUri));
}
}
catch (Exception ex)
{
return(null);
}
return(null);
}
public async Task <IActionResult> CreateAsync([FromBody] CreatePaymentRequestModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ErrorResponse().AddErrors(ModelState)));
}
try
{
IReadOnlyList <string> settlementAssets =
await _assetsAvailabilityService.ResolveSettlementAsync(model.MerchantId);
if (!settlementAssets.Contains(model.SettlementAssetId))
{
return(BadRequest(ErrorResponse.Create("Settlement asset is not available")));
}
IReadOnlyList <string> paymentAssets =
await _assetsAvailabilityService.ResolvePaymentAsync(model.MerchantId, model.SettlementAssetId);
if (!paymentAssets.Contains(model.PaymentAssetId))
{
return(BadRequest(ErrorResponse.Create("Payment asset is not available")));
}
var paymentRequest = Mapper.Map <PaymentRequest>(model);
IPaymentRequest createdPaymentRequest = await _paymentRequestService.CreateAsync(paymentRequest);
return(Ok(Mapper.Map <PaymentRequestModel>(createdPaymentRequest)));
}
catch (AssetUnknownException assetEx)
{
await _log.WriteErrorAsync(nameof(PaymentRequestsController), nameof(CreateAsync),
new { assetEx.Asset }.ToJson(), assetEx);
return(BadRequest(ErrorResponse.Create($"Asset {assetEx.Asset} can't be resolved")));
}
catch (Exception ex)
{
await _log.WriteErrorAsync(nameof(CreateAsync), model.ToJson(), ex);
throw;
}
}
[ProducesResponseType(typeof(CreatePaymentResponseModel), 200)] // OK
public async Task <IActionResult> CreatePayment(CreatePaymentRequestModel request)
{
_logger.LogInformation($"CreatePayment:{request}");
var response = await _paymentService.CreatePayment(_mapper.Map <Payment>(request));
var referenceCode = Guid.NewGuid();
if (response.ErrorCode == Consts.DUPLICATE_REQUEST_CODE)
{
_logger.LogError($"DUPLICATE_REQUEST. ReferenceCode:{referenceCode}");
return(Conflict(new ErrorResponseModel
{
ErrorCode = Consts.DUPLICATE_REQUEST_CODE,
Message = _errorMapper.GetMessage(response.ErrorCode, request.RequestId),
RequestId = request.RequestId,
ReferenceCode = referenceCode.ToString()
}));
}
if (response.ErrorCode == Consts.MERCHANT_INVALID_CODE)
{
_logger.LogError($"MERCHANT_INVALID. ReferenceCode:{referenceCode}");
return(BadRequest(new ErrorResponseModel
{
ErrorCode = Consts.MERCHANT_INVALID_CODE,
Message = _errorMapper.GetMessage(response.ErrorCode, request.MerchantId.ToString()),
RequestId = request.RequestId,
ReferenceCode = referenceCode.ToString()
}));
}
if (response.ErrorCode == Consts.MERCHANT_NOT_PRESENT_CODE)
{
_logger.LogError($"MERCHANT_NOT_PRESENT. ReferenceCode:{referenceCode}");
return(NotFound(new ErrorResponseModel
{
ErrorCode = Consts.MERCHANT_NOT_PRESENT_CODE,
Message = _errorMapper.GetMessage(response.ErrorCode, request.MerchantId.ToString()),
RequestId = request.RequestId,
ReferenceCode = referenceCode.ToString()
}));
}
_logger.LogInformation($"CreatePayment OK");
return(Ok(_mapper.Map <CreatePaymentResponseModel>(response)));
}
public async Task <CreatePaymentResponseModel> PostPaymentRequestAsync(CreatePaymentRequestModel requestModel)
{
var url = string.Empty;
var stringContent = new StringContent(JsonSerializer.Serialize(requestModel), Encoding.UTF8, UsedMediaType);
var responseRaw = await _httpClient.PostAsync(url, stringContent).ConfigureAwait(false);
// Possible improvement: Optimize resiliency with retry behavior
if (!responseRaw.IsSuccessStatusCode)
{
var errorMessage = await TryGetErrorMessage(responseRaw).ConfigureAwait(false);
throw new PaymentGatewayRequestException(responseRaw.StatusCode, responseRaw.ReasonPhrase, errorMessage);
}
var responseJson = await responseRaw.Content.ReadAsStringAsync().ConfigureAwait(false);
var response = JsonSerializer.Deserialize <CreatePaymentResponseModel>(responseJson);
return(response);
}
public Task <PaymentRequestModel> CreatePaymentRequestAsync(CreatePaymentRequestModel model)
{
return(_runner.RunAsync(() => _paymentRequestsApi.CreateAsync(model), ExceptionFactories.CreatePaymentRequestException));
}
public Task <PaymentRequestModel> CreatePaymentRequestAsync(CreatePaymentRequestModel model)
{
return(_runner.RunWithDefaultErrorHandlingAsync(() => _paymentRequestsApi.CreateAsync(model)));
}
