public async Task <IActionResult> ProcessPayment(PaymentRequestDTO paymentRequest)
{
try
{
if (ModelState.IsValid)
{
//in this the processing the payment take place
var paymentState = await _paymentRequestService.ProcessingPayment(paymentRequest);
var paymentResponse = new PaymentResponseDTO()
{
IsProcessed = paymentState.PaymentState == PaymentStateEnum.Processed
,
PaymentState = paymentState
};
//this will check if the payment is processed or not
if (!paymentResponse.IsProcessed)
{
return(StatusCode(500, new { error = "Payment could not be processed" }));
}
return(Ok(paymentResponse));
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(StatusCode(500));
}
}
public async void CreateBadRequest()
{
var dto = new PaymentRequestDTO();
var result = await _paymentService.CreatePaymentRequest(dto);
Assert.True(result != null && result.Reference == null && result.Reason == PaymentService.DataMissing);
}
public async Task <IHttpActionResult> ProcessPayment(PaymentRequestDTO requestdto)
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <PaymentRequestDTO, PaymentEntity>());
var mapper = new Mapper(config);
var dto = mapper.Map <PaymentEntity>(requestdto);
if (!ModelState.IsValid)
{
return(BadRequest("Invalid Request"));
}
if (!val.ValidateRequest(dto, out string errmsg))
{
return(BadRequest(errmsg));
}
if (await pay.ProcessPayment(dto))
{
dto.PaymentStatus = PaymentStateEntity.PROCESSED;
db.Payment.Add(dto);
db.SaveChanges();
return(Ok());
}
else
{
dto.PaymentStatus = PaymentStateEntity.FAILED;
db.Payment.Add(dto);
db.SaveChanges();
return(InternalServerError());
}
}
public async Task <Payment> MakePaymentAsync(Guid userId, PaymentRequestDTO paymentRequest)
{
var existPayment = await _context.Payments.FirstOrDefaultAsync(g => g.IdempotanceKey == paymentRequest.IdempotenceKey);
if (existPayment != null)
{
return(existPayment);
}
var payment = new Payment()
{
Amount = paymentRequest.Amount,
Date = DateTime.UtcNow,
UserId = userId,
IdempotanceKey = paymentRequest.IdempotenceKey,
};
try
{
_context.Payments.Add(payment);
var res = await _context.SaveChangesAsync();
}
catch (UniqueConstraintException)
{
return(await _context.Payments.FirstAsync(g => g.IdempotanceKey == paymentRequest.IdempotenceKey));
}
return(payment);
}
/// <summary>
/// Processes an existing payment request
/// </summary>
/// <param name="reference"></param>
/// <returns>
/// On Success returns a Reason and a reference in a PaymentRequestDTO
/// On failure returns a Reason in the PaymentRequestDTO indicating why the process failed
/// </returns>
public async Task <PaymentRequestDTO> ProcessPaymentRequest(string reference)
{
//Check Request exists
var data = await GetPaymentRequest(reference);
var dto = new PaymentRequestDTO();
if (data == null)
{
dto.Reason = $"Reference '{reference}' not found.";
return(dto);
}
//Check request is not Processed or Closed
if (data.RequestStatusId == (int)StatusOfRequest.Processed)
{
dto.Reason = $"Request could not be processed, {RequestReason.InvalidProcessRequestProcessed.GetDescription()}.";
return(dto);
}
if (data.RequestStatusId == (int)StatusOfRequest.Closed)
{
dto.Reason = $"Request could not be processed, {RequestReason.InvalidProcessRequestClosed.GetDescription()}.";
return(dto);
}
//Update payment request
var dbRequest = new PaymentRequest
{
Id = data.Id,
CustomerId = data.CustomerId,
CreatedOn = data.CreatedOn,
Amount = data.Amount,
RequestStatusId = (int)StatusOfRequest.Processed,
StatusReasonId = data.StatusReasonId,
Reference = data.Reference
};
_uow.PaymentRequests.Update(dbRequest);
//Create the transaction
var dbTransaction = new Transaction
{
Id = data.Id,
CustomerId = data.CustomerId,
CreatedOn = data.CreatedOn,
Amount = data.Amount * -1,
};
_uow.Transactions.Add(dbTransaction);
await _uow.Complete();
dto.Reference = data.Reference;
dto.Reason = $"Processed Payment Request with reference '{data.Reference}'";
dto.Status = StatusOfRequest.Processed.GetDescription();
return(dto);
}
public PaymentRequestDTO InitiatePayment(PaymentRequestDTO paymentDTO)
{
//HttpResponseMessage response = await client.PostAsJsonAsync("BankPayment/Payment", paymentDTO);
PaymentRequestDTO result = webApiHttpClient.RequestPost <PaymentRequestDTO, PaymentRequestDTO>("/BankPayment/Payment", paymentDTO); //Authentication not added due to time constraint
return(result);
//response.EnsureSuccessStatusCode();
//return response;
}
/// <summary>
/// Retrieve payment info
/// </summary>
public PaymentRequestDTO ViewTransactionHistory(PaymentRequestDTO paymentDTO)
{
HttpResponseMessage httpResponseMessage = new HttpResponseMessage();
try
{
return(GetTransaction(paymentDTO));
}
catch (Exception ex)
{
throw ex;
}
}
public HttpResponseMessage Payment([FromBody] PaymentRequestDTO req)
{
HttpResponseMessage response = new HttpResponseMessage();
try
{
req.CardNumber = "***" + req.CardNumber.Substring(req.CardNumber.Length - 3); //Mask the creditcard numder and resend objet as IS since it is a mock
response = Request.CreateResponse(HttpStatusCode.OK, req);
}
catch (Exception ex)
{
response.StatusCode = HttpStatusCode.InternalServerError;
response.Content = new StringContent(ex.Message);
}
return(response);
}
public IActionResult Pay(PaymentRequestDTO dto)
{
var usersession = (UserSession)HttpContext.Items["usersession"];
if (usersession.User.RoleId != 3)
{
return(Unauthorized());
}
var response = _userService.PayFromUser(dto, usersession.UserId);
if (response.HasError)
{
return(Error(response));
}
return(Ok(response));
}
public IHttpActionResult View([FromBody] PaymentRequestDTO req)
{
HttpResponseMessage response = new HttpResponseMessage();
PaymentRequestDTO paymentRequest = null;
try
{
paymentRequest = _paymentServices.ViewTransactionHistory(req);
}
catch (Exception ex)
{
response.StatusCode = HttpStatusCode.InternalServerError;
response.Content = new StringContent(ex.Message);
}
return(Ok(paymentRequest));
}
/// <summary>
/// Initiate an online payment
/// </summary>
public PaymentRequestDTO DoPayment(PaymentRequestDTO paymentDTO)
{
HttpResponseMessage httpResponseMessage = new HttpResponseMessage();
try
{
//httpResponseMessage.Content
return(InitiatePayment(paymentDTO));
}
catch (Exception ex)
{
//httpResponseMessage.StatusCode = HttpStatusCode.InternalServerError;
//httpResponseMessage.Content = new StringContent(ex.Message);
return(null);
}
}
public async Task <IActionResult> Create([FromBody] PaymentRequestDTO request)
{
try
{
var result = await _paymentService.CreatePaymentRequest(request);
if (string.IsNullOrEmpty(result.Reference))
{
return(BadRequest(result));
}
return(Ok(result));
}
catch (Exception ex)
{
Log.Logger.Error($"Error on PaymentRequestController.Create: {ex}");
return(BadRequest(ex));
}
}
public async void CreateSuccessfulRequest(string custId, double amount)
{
var reason = string.Empty;
var originalBalance = await _paymentService.GetBalance(custId);
var dto = new PaymentRequestDTO
{
CustomerId = custId,
Amount = amount
};
var result = await _paymentService.CreatePaymentRequest(dto);
var newBalance = await _paymentService.GetBalance(custId);
Assert.True(result != null &&
result.Reference.StartsWith(custId) &&
newBalance == (originalBalance - amount));
}
public async void CreateInsufficientFundsRequest(string custId, double amount)
{
var reason = string.Empty;
var originalBalance = await _paymentService.GetBalance(custId);
var dto = new PaymentRequestDTO
{
CustomerId = custId,
Amount = amount
};
var result = await _paymentService.CreatePaymentRequest(dto);
var newBalance = await _paymentService.GetBalance(custId);
Assert.True(result != null &&
result.Reference.StartsWith(custId) &&
result.Status == StatusOfRequest.Closed.GetDescription() &&
result.Reason == RequestReason.InsufficientFunds.GetDescription() &&
newBalance == originalBalance);
}
/// <summary>
/// Creates a payment request
/// </summary>
/// <param name="request"></param>
/// <returns>
/// On Success returns a PaymentRequest with the request reference
/// On failure returns a PaymentRequest with no reference and a reason
/// </returns>
public async Task <PaymentRequestDTO> CreatePaymentRequest(PaymentRequestDTO request)
{
//Validate inputs
if (request == null || request.Amount < 0 || string.IsNullOrEmpty(request.CustomerId))
{
request.Reason = DataMissing;
request.Reference = null;
return(request);
}
//Set defaults
var paymentStatus = (int)StatusOfRequest.Pending;
var paymentReason = (int)RequestReason.ValidRequest;
//If low funds the payment request should be created and closed
var currentBalance = await GetBalance(request.CustomerId);
if (request.Amount > currentBalance)
{
paymentReason = (int)RequestReason.InsufficientFunds;
paymentStatus = (int)StatusOfRequest.Closed;
}
//Create the payment request
var result = _uow.PaymentRequests.Create(new PaymentRequest
{
CustomerId = request.CustomerId,
Amount = request.Amount,
RequestStatusId = paymentStatus,
StatusReasonId = paymentReason,
});
await _uow.Complete();
// Return the created data
var data = await GetPaymentRequest(result.Id);
return(data);
}
public async Task <PaymentResponseDTO> ProcessPaymentAsync(Guid transaction_reference, PaymentRequestDTO paymentRequest)
{
PaymentResponseDTO paymentResponseDTO = _mapper.Map <PaymentResponseDTO>(paymentRequest);
paymentResponseDTO.Transaction_Reference_Id = transaction_reference;
try
{
#region Save/Retrieve Card
Card card_to_use;
//An Existing/Previously used card was provided so, retrieve from db
if (paymentRequest.Card_Info.Id.HasValue && paymentRequest.Card_Info.Id != Guid.Empty)
{
card_to_use = await _cardService.RetrieveCardByIdAndCvvAsync(paymentRequest.Card_Info.Id.Value, paymentRequest.Card_Info.Cvv);
if (card_to_use == null)
{
paymentResponseDTO.Status = StatusCode.INVALID_DATA;
paymentResponseDTO.Errors = new List <string>()
{
"Could not retrieve card, Invalid card id or cvv was provided"
};
return(paymentResponseDTO);
}
}
//A new card was provided so save to database (Not validating if the card exisits as it could be that another merchant saved the same user's card)
else
{
card_to_use = await _cardService.SaveCardAsync(paymentRequest.Card_Info);
}
CardResponseDTO cardResponseDTO = new CardResponseDTO(card_to_use.Number);
cardResponseDTO.Id = card_to_use.Id;
cardResponseDTO.Expiry_Month = card_to_use.Expiry_Month;
cardResponseDTO.Expiry_Year = card_to_use.Expiry_Year;
paymentResponseDTO.Card_Info = cardResponseDTO;
#endregion
#region Acquirer request and response
//Call the Acquiring Bank Service, set the acquirer_reference_id
AcquirerRequestDTO acquirerRequestDTO = new AcquirerRequestDTO();
acquirerRequestDTO.Transaction_Reference_id = transaction_reference;
acquirerRequestDTO.Amount = paymentRequest.Amount;
acquirerRequestDTO.Currency = paymentRequest.Currency;
acquirerRequestDTO.card = card_to_use;
acquirerRequestDTO.Payment_Description = paymentRequest.Payment_Description;
AcquirerResponseDTO acquirerResponseDTO = _acquirerService.ForwardPaymentRequestToAcquirer(acquirerRequestDTO);
paymentResponseDTO.Acquirer_Reference_Id = acquirerResponseDTO.Payment_Reference_Id;
paymentResponseDTO.Status = acquirerResponseDTO.Status;
paymentResponseDTO.Processed_On = acquirerResponseDTO.Processed_On;
#endregion
//Save Payment Response
await SavePaymentResponseAsync(paymentResponseDTO, card_to_use);
return(paymentResponseDTO);
}
catch (Exception ex)
{
//Log the exception
paymentResponseDTO.Errors = new List <string>()
{
StringConstants.UNEXPECTED_ERROR_MESSAGE
};
paymentResponseDTO.Status = Domain.DTOs.StatusCode.UNKNOWN;
}
return(paymentResponseDTO);
}
public override void OnActionExecuting(HttpActionContext actionContext)
{
String msgError = String.Empty;
bool isValidate = true;
System.Web.Http.ModelBinding.ModelStateDictionary model = new System.Web.Http.ModelBinding.ModelStateDictionary();
try
{
PaymentRequestDTO paymentRepresentationModel = new PaymentRequestDTO();
CardDetailsRequestDTO cardRepresentationModel = new CardDetailsRequestDTO();
PaymentConfirmationRequestDTO paymentConfRepresentationModel = new PaymentConfirmationRequestDTO();
try
{
paymentRepresentationModel = actionContext.ActionArguments["req"] as PaymentRequestDTO;
}
catch
{
paymentRepresentationModel = null;
};
try
{
paymentConfRepresentationModel = actionContext.ActionArguments["req"] as PaymentConfirmationRequestDTO;
}
catch
{
paymentConfRepresentationModel = null;
};
try
{
cardRepresentationModel = actionContext.ActionArguments["req"] as CardDetailsRequestDTO;
}
catch
{
cardRepresentationModel = null;
};
model = actionContext.ModelState;
msgError = "*** BAD REQUEST *** (" + actionContext.ActionDescriptor.ActionName + ") ";
// Test BAD REQUEST (400)
if (!model.IsValid)
{
msgError += string.Join(",",
model.Values.Where(e => e.Errors.Count > 0)
.SelectMany(e => e.Errors)
.Select(e => e.ErrorMessage)
.ToArray());
msgError += string.Join(",",
model.SelectMany(e => e.Value.Errors)
.Where(e => e.Exception != null)
.Select(e => e.Exception.Message)
.ToArray());
}
else
{
if (paymentRepresentationModel != null)
{
isValidate = ((paymentRepresentationModel.Amount != 0) && (paymentRepresentationModel.bearer.Any()) && (paymentRepresentationModel.CardNumber.Any()) && (paymentRepresentationModel.CvvCode != 0) /*Add more validation*/);
if (isValidate)
{
try
{
string jsonFormat = JsonConvert.SerializeObject(paymentRepresentationModel);
}
catch (JsonSerializationException e)
{
msgError += "Erreur :" + e.Message + ". Champs manquants";
isValidate = false;
}
}
else
{
msgError += "Format JSON erroné";
}
}
if (paymentConfRepresentationModel != null)
{
isValidate = ((paymentRepresentationModel.Amount != 0) && (paymentConfRepresentationModel.bearer.Any()) && (paymentConfRepresentationModel.CardNumber.Any()) && (paymentConfRepresentationModel.CvvCode != 0) /*Add more validation*/);
if (isValidate)
{
try
{
string jsonFormat = JsonConvert.SerializeObject(paymentConfRepresentationModel);
}
catch (JsonSerializationException e)
{
msgError += "Erreur :" + e.Message + ". Champs manquants";
isValidate = false;
}
}
else
{
msgError += "Format JSON erroné";
}
}
if (cardRepresentationModel != null && paymentRepresentationModel == null)
// PaymentRepresentation comprend CardRepresentation + Amount + Currency
//==> On considere un CardRepresentationEntity uniquement si la requete n'a pas ete identifiee comme PaymentRepresentation
{
isValidate = ((paymentRepresentationModel.bearer.Any()) && (paymentRepresentationModel.CardNumber.Any()) || (paymentRepresentationModel.CvvCode != 0) /*Add more validation*/);
if (isValidate)
{
try
{
string jsonFormat = JsonConvert.SerializeObject(cardRepresentationModel);
}
catch (JsonSerializationException e)
{
msgError += "Erreur :" + e.Message + ". Champs manquants";
isValidate = false;
}
}
else
{
msgError += "Format JSON erroné";
}
}
}
if (!model.IsValid || !isValidate)
{
throw new HttpResponseException(new HttpResponseMessage
{
StatusCode = HttpStatusCode.BadRequest,
Content = new StringContent(msgError),
ReasonPhrase = Utils.CleanNewLine(msgError)
});
}
}
catch (HttpResponseException ex)
{
//LoggerService.Instance.LogFatal("RequestFilter.OnActionExecuting", "Model non valide," + msgError);
throw ex;
}
catch (Exception ex)
{
//LoggerService.Instance.LogFatal("RequestFilter.OnActionExecuting", "Erreur de traitement: " + ex.Message);
throw new HttpResponseException(new HttpResponseMessage
{
StatusCode = HttpStatusCode.BadRequest,
Content = new StringContent(ex.Message),
ReasonPhrase = Utils.CleanNewLine(msgError)
});
}
base.OnActionExecuting(actionContext);
}
public async Task <ActionResult <PaymentDTO> > MakePayment(Guid userId, PaymentRequestDTO paymentRequest)
{
return(Ok());
}
public async Task <ActionResult <PaymentResponseDTO> > ProcessPayment([FromBody] PaymentRequestDTO paymentRequest)
{
try
{
if (paymentRequest == null)
{
return(BadRequest("Request was null"));
}
//Check if the request was made by the merchant who's secret_key was used
if (paymentRequest.merchant_id != _request_info.User_Id)
{
var invalidPaymentResponse = _mapper.Map <PaymentResponseDTO>(paymentRequest);
invalidPaymentResponse.Transaction_Reference_Id = _request_info.Transaction_Reference;
invalidPaymentResponse.Errors = new List <string>()
{
StringConstants.MERCHANT_SECRET_KEY_MISMATCH_MESSAGE
};
invalidPaymentResponse.Status = Domain.DTOs.StatusCode.INVALID_DATA;
return(Unauthorized(invalidPaymentResponse));
}
//Run the Fluent Validation Rules on the Model
var validationResult = _validator.Validate(paymentRequest);
if (validationResult.IsValid)
{
var result = await _paymentsService.ProcessPaymentAsync(_request_info.Transaction_Reference, paymentRequest);
//If Payment Response had errors it measns some business validations must have failed, return InvalidData Response
if (result.Errors != null && result.Errors.Count() > 0)
{
return(UnprocessableEntity(result));
}
else
{
//Payment was processed successfully
if (result.Status == Domain.DTOs.StatusCode.APPROVED)
{
return(CreatedAtAction(nameof(GetPaymentByUid), new { acquirer_reference_id = result.Acquirer_Reference_Id }, result));
}
//Payment was not processed successfully
else
{
return(UnprocessableEntity(result));
}
}
}
else
{
var invalidPaymentResponse = _mapper.Map <PaymentResponseDTO>(paymentRequest);
invalidPaymentResponse.Transaction_Reference_Id = _request_info.Transaction_Reference;
invalidPaymentResponse.Errors = validationResult.Errors.Select(x => x.ErrorMessage);
invalidPaymentResponse.Status = Domain.DTOs.StatusCode.INVALID_DATA;
return(UnprocessableEntity(invalidPaymentResponse));
}
}
catch (Exception ex)
{
//Log the actual exception
var errorPaymentResponse = _mapper.Map <PaymentResponseDTO>(paymentRequest);
errorPaymentResponse.Transaction_Reference_Id = _request_info.Transaction_Reference;
errorPaymentResponse.Errors = new List <string>()
{
StringConstants.UNEXPECTED_ERROR_MESSAGE
};
errorPaymentResponse.Status = Domain.DTOs.StatusCode.UNKNOWN;
return(BadRequest(errorPaymentResponse));
}
}
public Response <string> PayFromUser(PaymentRequestDTO dto, int UserId)
{
var response = new Response <string>();
string CardId = null;
try
{
var Order = _orderRepository.GetbyidwithInclude(a => a.Id == dto.PromoOrderId && a.DateDeleted == null, "User");
if (Order == null)
{
response.AddValidationError("", "Order doesnot exist.");
return(response);
}
if (dto.CardId == "" || dto.CardId == null)
{
var cardresponse = _cardService.Create(dto.CardDetail, UserId);
if (cardresponse.HasError)
{
response.ErrorMessage = cardresponse.ErrorMessage;
return(response);
}
CardId = cardresponse.Data;
}
else
{
CardId = _cardRepository.GetById(a => a.StripeCardId == dto.CardId && a.DateDeleted == null).StripeCardId;
}
var userResponse = _userRepository.GetbyidwithInclude(a => a.Id == UserId && a.DateDeleted == null, "Roles,Address");
if (userResponse == null)
{
response.AddValidationError("", "PromoOrder doesnot exist.");
return(response);
}
//Add Charge
double amt = Order.Net + Order.Fee;
double centamt = amt * 100;
double charge = (centamt * 2.9 / 100); // 2.9 % of service price
double centchanrge = (0.3 * 100); // 0.30 Fixed Charge
double totalCharg = charge + centchanrge;
double finalamount = centamt + totalCharg;
var responsepayment = _baseServices.Payment(new PaymentDTO
{
Amount = Convert.ToInt64(Math.Ceiling(finalamount)),
Currency = "usd",
CustomerId = userResponse.Stripe_CustomerId,
CardId = CardId,
Desciption = "Pay for Test",
Metadata = new Dictionary <string, string>
{
{ "OrderId", Order.Id.ToString() },
{ "Service Title", "" },
{ "Discount", Order.Discount.ToString() },
{ "Fee", Order.Fee.ToString() }
},
address = userResponse.Address
});
if (!responsepayment.Success)
{
response.ErrorMessage = responsepayment.ErrorMessage;
return(response);
}
if (responsepayment.Success && responsepayment.Data != null && responsepayment.Data.Status == "succeeded")
{
Order.PaymentStaus = PaymentStaus.Completed;
}
else if (responsepayment.Success && responsepayment.Data != null && responsepayment.Data.Status == "pending")
{
Order.PaymentStaus = PaymentStaus.Pending;
}
else if (responsepayment.Success && responsepayment.Data != null && responsepayment.Data.Status == "failed")
{
Order.PaymentStaus = PaymentStaus.Reject;
}
Order.ChargeId = responsepayment.Data.Id;
_orderRepository.Update(Order);
response.Data = responsepayment.Data.Id;
response.Success = true;
}
catch (Exception ex)
{
HandleException(response, ex);
}
return(response);
}