public async Task <ActionResult <PaymentResponseModel> > Post()
{
PaymentResponse paymentResult;
paymentResult = await _paymentService.MakePayment();
if (paymentResult.Message != "Connection error.")
{
PaymentResponseModel model = new PaymentResponseModel
{
IsSuccess = paymentResult.IsSuccess,
Message = paymentResult.Message
};
if (!model.IsSuccess)
{
return(BadRequest(model));
}
return(Ok(model));
}
else
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.PAYMENT_CREATION_ERROR,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
}
public async Task <ActionResult> KnetResponse()
{
string transData = HttpContext.Request.Form["trandata"];
PaymentResponseModel objResponse = await new PaymentUtility().AuthenticatePayment(transData);
if (objResponse is PaymentResponseModel && !string.IsNullOrEmpty(objResponse.Result) && objResponse.Result.ToUpper() == "CAPTURED")
{
PaymentHistoryModel oIncomingPay = new PaymentHistoryModel();
string CardCode = objResponse.UDF1.Split('_')[0];
string CardName = objResponse.UDF1.Split('_')[0];
string[] DocEntryNos = objResponse.UDF2.Split('_');
string[] DocNumbers = objResponse.UDF3.Split('_');
string[] TransferSums = objResponse.UDF4.Split('_');
string[] BranchIDs = objResponse.UDF5.Split('_');
for (int invCnt = 0; invCnt < DocEntryNos.Length; invCnt++)
{
oIncomingPay.IncomingPaymentData.Add(new IncomingPayment
{
CardCode = CardCode,
CardName = CardName,
DocEntryNo = DocEntryNos[invCnt],
DocNumber = DocNumbers[invCnt],
Remarks = "KNET Payment",
TransferSum = double.Parse(TransferSums[invCnt]),
BranchID = int.Parse(BranchIDs[invCnt]),
TransferRefrence = objResponse.PayReference
});
}
RentPayResponseModel paySaveRsp = await Connector.PayRentDue(oIncomingPay) as RentPayResponseModel;
}
return(View(@"~\Views\Rent\PayReciept.cshtml", objResponse));
}
public async Task ProcessPayment_Ok()
{
//Arrange
var paymentDto = new PaymentDto()
{
Id = 1,
CreditCardNumber = "2204-1232-9746-5558",
CardHolder = "James Smith",
ExpirationDate = DateTime.Now.AddYears(1),
SecurityCode = "331",
Amount = 451.25M,
State = new PaymentStateDto {
PaymentId = 1, Status = PaymentStatus.Processed
}
};
var responseModel = new PaymentResponseModel();
mockMapper.Setup(x => x.Map <PaymentResponseModel>(paymentDto)).Returns(responseModel);
mockProcessService.Setup(service => service.ProcessPayment(paymentDto)).Returns(Task.FromResult(responseModel));
//Act
var act = await mockController.ProcessPayment(paymentDto) as ObjectResult;
//Assert
Assert.Equal(act.StatusCode, StatusCodes.Status200OK);
}
public async Task <PaymentResponseModel> InitiatePayment(PaymentRequestModel payModel)
{
PaymentResponseModel dtoPayResponse = new PaymentResponseModel();
try
{
ARMvc.KnetService.RequestModel objRequest = new ARMvc.KnetService.RequestModel()
{
Amount = payModel.Amount,
ReffNo = payModel.ReffNo,
UDF1 = payModel.UDF1,
UDF2 = payModel.UDF2,
UDF3 = payModel.UDF3,
UDF4 = payModel.UDF4,
UDF5 = payModel.UDF5,
KNETConfig = new ARMvc.KnetService.Configuration()
{
Language = ConfigSettings.KnetLanguage,
AliasName = ConfigSettings.KnetAliasName,
ResponseURL = string.Format(ConfigSettings.KnetResponseURL, payModel.Culture),
ErrorURL = string.Format(ConfigSettings.KnetErrorURL),
ResourcePath = ConfigSettings.KnetResourcePath,
KnetCurrency = ConfigSettings.KnetCurrency
}
};
ARMvc.KnetService.ResponseModel objResponse = await new ARMvc.KnetService.KNETServiceClient().InitPaymentAsync(objRequest);
dtoPayResponse = ObjectAutoMap.Map <ARMvc.KnetService.ResponseModel, PaymentResponseModel>(objResponse);
}
catch (Exception ex)
{
dtoPayResponse = ObjectAutoMap.Map <PaymentRequestModel, PaymentResponseModel>(payModel);
dtoPayResponse.ErrorMessage = "Payment service is down. Please try again later";
}
return(dtoPayResponse);
}
public PaymentResponseModel ProcessPremiumPayment(PaymentDto paymentDto, PaymentResponseModel responseModel)
{
responseModel.Success = true;
responseModel.Status = PaymentStatus.Processed;
responseModel.State = new PaymentStateDto {
Status = PaymentStatus.Processed
};
return(responseModel);
}
private Task HandleExceptionAsync(HttpContext context, Exception exception, string referenceCode)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
var obj = new PaymentResponseModel()
{
ReferenceCode = referenceCode,
ErrorCode = Consts.UKNOWN_ERROR_CODE,
Message = $"Unmanaged Exception. Message:{exception.Message}"
};
return(context.Response.WriteAsync(JsonConvert.SerializeObject(obj)));
}
public async Task <ActionResult> PayRent(PaymentRequestModel RQ)
{
UserModel objUser = Session[SessionConstants.UserSession] as UserModel;
RQ.UDF1 = objUser.CardCode + "_" + objUser.CardName;
RQ.Culture = Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName;
PaymentResponseModel objResponse = await new PaymentUtility().InitiatePayment(RQ);
if (objResponse is PaymentResponseModel && string.IsNullOrEmpty(objResponse.ErrorMessage))
{
Response.Redirect(objResponse.RedirectionURL);
}
return(View(@"~\Views\Rent\PayReciept.cshtml", objResponse));
}
public async Task ProcessPayment_InternalServerError()
{
//Arrange
PaymentDto paymentDto = null;
PaymentResponseModel responseModel = null;
mockMapper.Setup(x => x.Map <PaymentResponseModel>(paymentDto)).Returns(responseModel);
mockProcessService.Setup(service => service.ProcessPayment(paymentDto)).Returns(Task.FromResult(responseModel));
//Act
var act = await mockController.ProcessPayment(paymentDto) as ObjectResult;
//Assert
Assert.Equal(act.StatusCode, StatusCodes.Status500InternalServerError);
}
public async Task ProcessPayment_BadRequest()
{
//Arrange
var paymentDto = new PaymentDto();
var responseModel = new PaymentResponseModel();
mockMapper.Setup(x => x.Map <PaymentResponseModel>(paymentDto)).Returns(responseModel);
mockProcessService.Setup(service => service.IsValidRequest(responseModel)).Returns(true);
//Act
var act = await mockController.ProcessPayment(paymentDto) as ObjectResult;
//Assert
Assert.Equal(act.StatusCode, StatusCodes.Status400BadRequest);
}
public ActionResult GatewayResponse()
{
string resultCode = Request.Params["ResultCode"];
string resultMessage = Request.Params["ResultMessage"];
string transactionIdentifier = Request.Params["TransactionIdentifier"];
PaymentResponseModel model = new PaymentResponseModel()
{
ResultCode = resultCode,
ResultMessage = resultMessage,
TransactionIdentifier = transactionIdentifier
};
return(View(model));
}
private void AssumeModelIsInitialized()
{
_paymentRequest = new PaymentRequest
{
MerchantId = 12020,
CardNumber = "1234567891234567",
ExpiryDate = "10/21",
CardIssuer = "VISA",
Cvv = 111,
Amount = 12.10M,
NameOnTheCard = "Mr Test",
PostCode = "SS1 9SS"
};
_paymentRequestModel = new PaymentRequestModel
{
MerchantId = 12020,
Card = new Card
{
Number = "1234567891234567",
Issuer = "VISA",
Cvv = 111,
NameOnTheCard = "Mr Test",
PostCode = "SS1 9SS"
},
Amount = 12.10M,
};
_paymentResponseModel = new PaymentResponseModel
{
MerchantId = 12020,
CardNumber = "XXXXXXXXXXXX4567",
Approved = true,
StatusCode = "authorized"
};
_paymentResponse = new PaymentResponse
{
MerchantId = 12020,
CardNumber = "XXXXXXXXXXXX4567",
Approved = true,
StatusCode = "authorized"
};
}
async Task <PaymentResponseModel> PayOrder(long requestId, decimal price, string buyer_key)
{
PaymentResponseModel responseData = new PaymentResponseModel();
System.Threading.CancellationTokenSource cts;
HttpClient httpClient = new HttpClient();
TimeSpan time = new TimeSpan(0, 0, 60);
httpClient.Timeout = time;
cts = new System.Threading.CancellationTokenSource();
cts.CancelAfter(time);
PaymentRequestModel model = new PaymentRequestModel()
{
buyer_key = buyer_key,
capture_buyer = 0,
currency = Common.payme_currency,
installments = 1,
payme_sale_id = Common.payme_sale_id,
product_name = "Order #" + requestId,
sale_callback_url = Common.payme_sale_callback_url,
sale_price = 1,//price,
sale_return_url = Common.payme_sale_return_url,
seller_payme_id = Common.payme_sale_id,
transaction_id = requestId.ToString(),// "12345",
};
string postData = Newtonsoft.Json.JsonConvert.SerializeObject(model);
string url = Common.payme_PaymentUrl;
StringContent str = new StringContent(postData, System.Text.Encoding.UTF8, "application/json");
var result = await httpClient.PostAsync(new Uri(url), str);
var place = result.Content.ReadAsStringAsync().Result;
// deserialization of the response returning from the api
responseData = Newtonsoft.Json.JsonConvert.DeserializeObject <PaymentResponseModel>
(await result.Content.ReadAsStringAsync());
return(responseData);
}
public bool IsValidRequest(PaymentResponseModel paymentResponse)
{
if (string.IsNullOrWhiteSpace(paymentResponse.CreditCardNumber))
{
paymentResponse.Errors.Add("credit card number please");
}
if (!string.IsNullOrWhiteSpace(paymentResponse.CreditCardNumber))
{
//2204-1232-9746-5558, or 1111-1111-1111-1111.
Regex regex = new Regex("^[1-9][0-9]{3}-[1-3]{4}-[0-9]{4}-[0-9]{4}$");
var result = regex.Match(paymentResponse.CreditCardNumber);
if (!result.Success)
{
paymentResponse.Errors.Add("valid credit card number please");
}
}
if (string.IsNullOrWhiteSpace(paymentResponse.CardHolder))
{
paymentResponse.Errors.Add("credit card number please");
}
if (string.IsNullOrWhiteSpace(paymentResponse.CardHolder))
{
paymentResponse.Errors.Add("card holder name please");
}
if (paymentResponse.SecurityCode.Length > 3)
{
paymentResponse.Errors.Add("security code should have max 3 charcaters only");
}
if (paymentResponse.ExpirationDate < DateTime.Today)
{
paymentResponse.Errors.Add("please make sure card is not expired");
}
if (paymentResponse.Amount <= 0.0M)
{
paymentResponse.Errors.Add("enter valid amount please");
}
return(paymentResponse.Errors.Any());
}
public void Post_Async_Return_Payment_Response_Not_SuccessFull_Bad_Request()
{
//Arrange
int expectedStatusCode = 400;
PaymentResponse paymentResult = new PaymentResponse();
paymentResult.IsSuccess = false;
Task <PaymentResponse> responseTask = Task.FromResult(paymentResult);
_paymentService = new Mock <ILevi9PaymentService>();
_paymentService.Setup(x => x.MakePayment()).Returns(responseTask);
Levi9PaymentController levi9PaymentController = new Levi9PaymentController(_paymentService.Object);
//Act
var result = levi9PaymentController.Post().ConfigureAwait(false).GetAwaiter().GetResult().Result;
var objectResult = ((BadRequestObjectResult)result).Value;
PaymentResponseModel model = (PaymentResponseModel)objectResult;
//Assert
Assert.IsNotNull(objectResult);
Assert.IsInstanceOfType(result, typeof(BadRequestObjectResult));
Assert.AreEqual(expectedStatusCode, ((BadRequestObjectResult)result).StatusCode);
}
public PaymentResponseModel CreatePaymentOrder(int loginid, string ordernumber, int storeid)
{
PaymentResponseModel response = new PaymentResponseModel();
string transaction_id = "";
string OrderNumber = "";
using (sjb_androidEntities context = new sjb_androidEntities())
{
var orderDetails = (from r in context.registrationmasters
join o in context.ordermasters on r.LoginID equals o.LoginId
where r.LoginID == loginid && o.OrderNumber == ordernumber && o.StoreId == storeid
select new PaymentGatewayModel()
{
name = r.Name,
phone = r.PhoneNumber,
email = r.EmailID,
description = o.OrderNumber,
amount = (double)o.NetAmount
}).First();
//For Production
//string Insta_client_id = "YPmEwDVMbYy4hH9EZOcY4Vsw3xJWjnAd3qlTS85J",
// Insta_client_secret = "fSiNKEG8PRLdOXSzpQrBba02Ix1sfbxDSHg3f562AFY0YqvgKXMm70wbE6vqxzmmpVOKB1MyG3tlwDzX4rzNXwRwqaHVafFQv1gkj4kNf14x1eeync9PoMuGtOulBxJk",
// Insta_Endpoint = InstamojoConstants.INSTAMOJO_API_ENDPOINT,
// Insta_Auth_Endpoint = InstamojoConstants.INSTAMOJO_AUTH_ENDPOINT;
//For Test
string Insta_client_id = "";
string Insta_client_secret = "";
string Insta_Endpoint = "";
string Insta_Auth_Endpoint = "";
if (storeid == 1)
{
Insta_client_id = "HhWceDXORiCKCKIechUmXZX6vd4nj44kKvCUIVJv";
Insta_client_secret = "5B6CAfNsEoaakuzWLia7CMtgFsp6gt0MTrN5jR0MzsTIerNXKjmS9k1bBS1J8LdANjKXWtmlR1RuiOM8o71JVYYawBCl4NRiWbpKrI8OwkwnjNlvOuYRnjfkGnjozZDM";
Insta_Endpoint = InstamojoConstants.INSTAMOJO_API_ENDPOINT;
Insta_Auth_Endpoint = InstamojoConstants.INSTAMOJO_AUTH_ENDPOINT;
}
if (storeid == 2)
{
Insta_client_id = "tmLkZZ0zV41nJwhayBGBOI4m4I7bH55qpUBdEXGS";
Insta_client_secret = "IDejdccGqKaFlGav9bntKULvMZ0g7twVFolC9gdrh9peMS0megSFr7iDpWwWIDgFUc3W5SlX99fKnhxsoy6ipdAv9JeQwebmOU6VRvOEQnNMWwZnWglYmDGrfgKRheXs";
Insta_Endpoint = InstamojoConstants.INSTAMOJO_API_ENDPOINT;
Insta_Auth_Endpoint = InstamojoConstants.INSTAMOJO_AUTH_ENDPOINT;
}
if (storeid == 3)
{
Insta_client_id = "tmLkZZ0zV41nJwhayBGBOI4m4I7bH55qpUBdEXGS";
Insta_client_secret = "IDejdccGqKaFlGav9bntKULvMZ0g7twVFolC9gdrh9peMS0megSFr7iDpWwWIDgFUc3W5SlX99fKnhxsoy6ipdAv9JeQwebmOU6VRvOEQnNMWwZnWglYmDGrfgKRheXs";
Insta_Endpoint = InstamojoConstants.INSTAMOJO_API_ENDPOINT;
Insta_Auth_Endpoint = InstamojoConstants.INSTAMOJO_AUTH_ENDPOINT;
}
InstamojoAPI.Instamojo objClass = InstamojoImplementation.getApi(Insta_client_id, Insta_client_secret, Insta_Endpoint, Insta_Auth_Endpoint);
PaymentOrder objPaymentRequest = new PaymentOrder();
//Required POST parameters
objPaymentRequest.name = orderDetails.name;
objPaymentRequest.email = orderDetails.email;
objPaymentRequest.phone = orderDetails.phone;
objPaymentRequest.description = orderDetails.description;
objPaymentRequest.amount = orderDetails.amount;
objPaymentRequest.currency = "INR";
string randomName = Path.GetRandomFileName();
randomName = randomName.Replace(".", string.Empty);
objPaymentRequest.transaction_id = "EVG" + randomName;
transaction_id = objPaymentRequest.transaction_id;
OrderNumber = objPaymentRequest.description;
//For Production
//objPaymentRequest.redirect_url = "http://103.233.79.234:1000/";
//objPaymentRequest.webhook_url = "https://your.server.com/webhook";
//Extra POST parameters
//For Test
objPaymentRequest.redirect_url = "https://swaggerhub.com/api/saich/pay-with-instamojo/1.0.0";
objPaymentRequest.webhook_url = "https://your.server.com/webhook";
if (objPaymentRequest.validate())
{
//if (objPaymentRequest.emailInvalid)
//{
// response.Message = "Email is not valid";
//}
//if (objPaymentRequest.nameInvalid)
//{
// response.Message = "Name is not valid";
//}
if (objPaymentRequest.phoneInvalid)
{
response.Message = "Phone is not valid";
}
if (objPaymentRequest.amountInvalid)
{
response.Message = "Amount is not valid";
}
if (objPaymentRequest.currencyInvalid)
{
response.Message = "Currency is not valid";
}
if (objPaymentRequest.transactionIdInvalid)
{
response.Message = "Transaction Id is not valid";
}
if (objPaymentRequest.redirectUrlInvalid)
{
response.Message = "Redirect Url Id is not valid";
}
if (objPaymentRequest.webhookUrlInvalid)
{
response.Message = "Webhook URL is not valid";
}
}
else
{
try
{
CreatePaymentOrderResponse objPaymentResponse = objClass.createNewPaymentRequest(objPaymentRequest);
response.PaymentURL = objPaymentResponse.payment_options.payment_url;
var data = context.ordermasters.Where(x => x.LoginId == loginid && x.OrderNumber == ordernumber && x.StoreId == storeid).FirstOrDefault();
if (data != null)
{
context.ordermasters.Where(x => x.LoginId == loginid && x.OrderNumber == ordernumber && x.StoreId == storeid).ToList().ForEach(x => x.TranactionId = transaction_id);
context.SaveChanges();
}
}
catch (ArgumentNullException ex)
{
response.Message = ex.Message;
}
catch (WebException ex)
{
response.Message = ex.Message;
}
catch (IOException ex)
{
response.Message = ex.Message;
}
catch (InvalidPaymentOrderException ex)
{
if (!ex.IsWebhookValid())
{
response.Message = "Webhook is invalid";
}
if (!ex.IsCurrencyValid())
{
response.Message = "Currency is Invalid";
}
if (!ex.IsTransactionIDValid())
{
response.Message = "Transaction ID is Invalid";
}
}
catch (ConnectionException ex)
{
response.Message = ex.Message;
}
catch (BaseException ex)
{
response.Message = ex.Message;
}
catch (Exception ex)
{
response.Message = ex.Message;
}
}
}
return(response);
}
