public void OnConfirmPaymentRequest(ConfirmPaymentRequest request)
{
OnConfirmPaymentRequestMessage onConfirmPaymentRequest = new OnConfirmPaymentRequestMessage();
onConfirmPaymentRequest.payload = request;
WebSocket.Send(Serialize(onConfirmPaymentRequest));
}
public async Task <IActionResult> Confirm(Guid transactionId, string md, string paRes)
{
var confirmPaymentRequest = new ConfirmPaymentRequest
{
PaRes = paRes,
TransactionId = transactionId
};
try
{
var response = await _paymentApiClient.ConfirmPaymentAsync(confirmPaymentRequest);
var model = new PaymentConfirmedModel
{
Status = response.Status,
TransactionId = response.TransactionId
};
return(View(model));
}
catch (Exception e)
{
_logger.LogError(e, "An error happened while calling Payment Api");
if (e is ApiException apiEx)
{
ViewBag.Error = apiEx.GetErrorDescription();
}
else
{
ViewBag.Error = e.Message;
}
return(View(new PaymentConfirmedModel()));
}
}
public void ConfirmPaymentRequest(HttpListenerContext context)
{
ConfirmPaymentRequest request = ParseResponse <ConfirmPaymentRequest>(context);
connectorListener.ForEach(listener => listener.OnConfirmPaymentRequest(request));
SendTextResponse(context, "");
}
public async Task <object> ConfirmPaymentAsync(ConfirmPaymentRequest request)
{
var token = this.httpClientFactory.Token(HttpClientFactory.APIType.ZohoSubscription).Result.AccessToken;
// var userMapping = context.WpZohocustomerMapping.Where(u => u.UserId == long.Parse(request.UserId)).FirstOrDefault();
ConfirmZohoPaymentRequest paymentRequest = new ConfirmZohoPaymentRequest();
//if (User != null)
// paymentRequest.CustomerId = userMapping.ZohoCustomerId;
//else
paymentRequest.CustomerId = request.CustomerID;
paymentRequest.PaymentMode = "other";
paymentRequest.Amount = Convert.ToDecimal(request.Amount);
// paymentRequest.Date = Convert.ToDateTime(request.InvoiceDate).ToShortDateString();
paymentRequest.ReferenceNumber = request.ReferenceNumber;
paymentRequest.Description = $"Payment has been added to Invoice and your Payment reference : {paymentRequest.ReferenceNumber}";
paymentRequest.Invoices = new List <Invoice>()
{
new Invoice()
{
InvoiceId = request.InvoiceID,
AmountApplied = Convert.ToDecimal(request.Amount)
}
};
var paymentURL = "https://subscriptions.zoho.com/api/v1/payments";
var paymentResponse = await this.httpClientFactory.PostAsync <ConfirmZohoPaymentResponse, ConfirmZohoPaymentRequest>(paymentURL, paymentRequest
, HttpClientFactory.APIType.ZohoSubscription, token);
if (paymentResponse.result.Code == 0)
{
var paymentReferenceURL = $"https://subscriptions.zoho.com/api/v1/subscriptions/{request.SubscriptionID}/customfields";
var updatePaymentReferenceRequest = new UpdatePaymentReferenceRequest();
updatePaymentReferenceRequest.CustomFields = new List <PaymentReferenceCustomField>()
{
new PaymentReferenceCustomField()
{
Label = "PaymentReferenceNo",
Value = request.ReferenceNumber
}
};
var updatePaymentReferenceResponse = await this.httpClientFactory.PostAsync <UpdatePaymentReferenceResponse, UpdatePaymentReferenceRequest>(
paymentReferenceURL, updatePaymentReferenceRequest, HttpClientFactory.APIType.ZohoSubscription, token
);
return(new
{
Status = true,
Message = "Success",
Data = paymentResponse.result.Payment
});
}
else
{
return(new { Status = false, Message = paymentResponse.result.Message });
}
}
public IActionResult PerformTransaction([FromBody] ConfirmPaymentRequest request)
{
ConfirmPaymentResponse response = new ConfirmPaymentResponse();
response.TransactionStatus = 1;
response.AdditionalInfo = "string information" + "\n" + "Basic Info:" + request.BasicInfo.ToString();;
response.TransactionId = request.TransactionId;
response.CurrentBalance = 200.36;
response.CompletionDateTime = DateTime.Now.ToString(Constants.Constants.DateTimeFormat);
response.TotalAmount = request.TotalAmount;
response.CurrencyCode = request.CurrencyCode;
return(Ok(response));
}
public void ConfirmPaymentRequest(HttpListenerContext context)
{
try
{
ConfirmPaymentRequest request = ParseResponse <ConfirmPaymentRequest>(context);
connectorListener.ForEach(listener => listener.OnConfirmPaymentRequest(request));
SendTextResponse(context, "");
}
catch (Exception e)
{
context.Response.StatusCode = 400;
context.Response.StatusDescription = e.Message;
SendTextResponse(context, "error processing request");
}
}
public async Task <ConfirmPaymentResponse> ConfirmPaymentAsync(ConfirmPaymentRequest request)
{
Guard.ArgumentNotNull(request, nameof(request));
var definition = new RequestDefinition
{
Url = "/confirm",
Method = HttpMethods.Post,
Body = this.Serialize(request)
};
this.logger.LogTrace($"Start send confirm payment request to [{definition.Method}] {this.GetRequestUrl(definition)}");
var rawResult = await this.ApplyAsync(definition);
return(this.Deserialize <ConfirmPaymentResponse>(rawResult));
}
public ConfirmPaymentResponse PerformTransaction(ConfirmPaymentRequest request)
{
HttpResponseMessage response = MockupsAPIsCaller.CallAPI(request, "api/Payment/MerchantToSR/PerformTransaction");
if (response.StatusCode == HttpStatusCode.OK)
{
string ResponseString = (response.Content.ReadAsStringAsync()).Result;
ConfirmPaymentResponse confirmPaymentResponse = JsonConvert.DeserializeObject <ConfirmPaymentResponse>(ResponseString);
return(confirmPaymentResponse);
}
else if (response.StatusCode == (HttpStatusCode)490)
{
throw MockupsAPIsCaller.GenerateError(response);
}
throw new Exception();
}
public override void OnConfirmPaymentRequest(ConfirmPaymentRequest request)
{
for (int i = 0; i < request.Challenges.Count; i++)
{
if (request.Challenges[i].type == ChallengeType.DUPLICATE_CHALLENGE)
{
}
else if (request.Challenges[i].type == ChallengeType.OFFLINE_CHALLENGE)
{
}
//if (request.Payment.offline)
//{
// deviceOffline = true;
// cloverConnector.ShowMessage("TRANSACTION ERROR:\nDEVICE OFFLINE");
// File.WriteAllText(SaleFilePath, "FAILED\tOFFLINE");
// this.cloverConnector.RejectPayment(request.Payment, request.Challenges[i]);
//}
}
this.cloverConnector.AcceptPayment(request.Payment);
}
public void OnConfirmPaymentRequest(ConfirmPaymentRequest request) => Event?.Invoke(this, EventFrom("ConfirmPaymentRequest", request));
private void websocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
// do the parsing of the message, targeted for the callback listener
JObject jsonObj = null;
try
{
jsonObj = (JObject)JsonConvert.DeserializeObject(e.Message);
}
catch (Exception exc)
{
Console.WriteLine(exc.Message + " => " + e.Message);
listeners.ForEach(listener => listener.OnDeviceError(new CloverDeviceErrorEvent(CloverDeviceErrorEvent.CloverDeviceErrorType.EXCEPTION, 0, exc.Message + " => " + e.Message)));
return;
}
JToken method = jsonObj.GetValue(ServicePayloadConstants.PROP_METHOD);
if (method == null)
{
listeners.ForEach(listener => listener.OnDeviceError(new CloverDeviceErrorEvent(CloverDeviceErrorEvent.CloverDeviceErrorType.VALIDATION_ERROR, 0, "Invalid message: " + e.Message)));
return;
}
JObject payload = (JObject)jsonObj.GetValue(ServicePayloadConstants.PROP_PAYLOAD);
WebSocketMethod wsm = (WebSocketMethod)Enum.Parse(typeof(WebSocketMethod), method.ToString());
switch (wsm)
{
case WebSocketMethod.DeviceActivityStart:
{
CloverDeviceEvent deviceEvent = JsonUtils.deserialize <CloverDeviceEvent>(payload.ToString());
listeners.ForEach(listener => listener.OnDeviceActivityStart(deviceEvent));
break;
}
case WebSocketMethod.DeviceActivityEnd:
{
CloverDeviceEvent deviceEvent = JsonUtils.deserialize <CloverDeviceEvent>(payload.ToString());
listeners.ForEach(listener => listener.OnDeviceActivityEnd(deviceEvent));
break;
}
case WebSocketMethod.DeviceError:
{
CloverDeviceErrorEvent deviceErrorEvent = JsonUtils.deserialize <CloverDeviceErrorEvent>(payload.ToString());
listeners.ForEach(listener => listener.OnDeviceError(deviceErrorEvent));
break;
}
case WebSocketMethod.DeviceConnected:
{
listeners.ForEach(listener => listener.OnDeviceConnected());
break;
}
case WebSocketMethod.DeviceDisconnected:
{
listeners.ForEach(listener => listener.OnDeviceDisconnected());
break;
}
case WebSocketMethod.DeviceReady:
{
MerchantInfo merchantInfo = JsonUtils.deserialize <MerchantInfo>(payload.ToString());
listeners.ForEach(listener => listener.OnDeviceReady(merchantInfo));
break;
}
case WebSocketMethod.VerifySignatureRequest:
{
VerifySignatureRequest svr = JsonUtils.deserialize <VerifySignatureRequest>(payload.ToString());
WebSocketSigVerRequestHandler handler = new WebSocketSigVerRequestHandler(this, svr);
listeners.ForEach(listener => listener.OnVerifySignatureRequest(handler));
break;
}
case WebSocketMethod.SaleResponse:
{
SaleResponse sr = JsonUtils.deserialize <SaleResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnSaleResponse(sr));
break;
}
case WebSocketMethod.PreAuthResponse:
{
PreAuthResponse pr = JsonUtils.deserialize <PreAuthResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnPreAuthResponse(pr));
break;
}
case WebSocketMethod.AuthResponse:
{
AuthResponse ar = JsonUtils.deserialize <AuthResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnAuthResponse(ar));
break;
}
case WebSocketMethod.CapturePreAuthResponse:
{
CapturePreAuthResponse ar = JsonUtils.deserialize <CapturePreAuthResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnCapturePreAuthResponse(ar));
break;
}
case WebSocketMethod.RefundPaymentResponse:
{
RefundPaymentResponse sr = JsonUtils.deserialize <RefundPaymentResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnRefundPaymentResponse(sr));
break;
}
case WebSocketMethod.VoidPaymentResponse:
{
VoidPaymentResponse sr = JsonUtils.deserialize <VoidPaymentResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnVoidPaymentResponse(sr));
break;
}
case WebSocketMethod.ManualRefundResponse:
{
ManualRefundResponse sr = JsonUtils.deserialize <ManualRefundResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnManualRefundResponse(sr));
break;
}
case WebSocketMethod.TipAdjustAuthResponse:
{
TipAdjustAuthResponse taar = JsonUtils.deserialize <TipAdjustAuthResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnTipAdjustAuthResponse(taar));
break;
}
case WebSocketMethod.VaultCardResponse:
{
VaultCardResponse vcr = JsonUtils.deserialize <VaultCardResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnVaultCardResponse(vcr));
break;
}
case WebSocketMethod.ReadCardDataResponse:
{
ReadCardDataResponse rcdr = JsonUtils.deserialize <ReadCardDataResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnReadCardDataResponse(rcdr));
break;
}
case WebSocketMethod.CloseoutResponse:
{
CloseoutResponse cr = JsonUtils.deserialize <CloseoutResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnCloseoutResponse(cr));
break;
}
case WebSocketMethod.ConfirmPaymentRequest:
{
ConfirmPaymentRequest cpr = JsonUtils.deserialize <ConfirmPaymentRequest>(payload.ToString());
listeners.ForEach(listener => listener.OnConfirmPaymentRequest(cpr));
break;
}
case WebSocketMethod.RetrievePendingPaymentsResponse:
{
RetrievePendingPaymentsResponse rppr = JsonUtils.deserialize <RetrievePendingPaymentsResponse>(payload.ToString());
listeners.ForEach(listener => listener.OnRetrievePendingPaymentsResponse(rppr));
break;
}
case WebSocketMethod.PrintManualRefundDeclinedReceipt:
{
PrintManualRefundDeclineReceiptMessage pmrdrm = JsonUtils.deserialize <PrintManualRefundDeclineReceiptMessage>(payload.ToString());
listeners.ForEach(listener => listener.OnPrintManualRefundDeclineReceipt(pmrdrm));
break;
}
case WebSocketMethod.PrintManualRefundReceipt:
{
PrintManualRefundReceiptMessage pmrrm = JsonUtils.deserialize <PrintManualRefundReceiptMessage>(payload.ToString());
listeners.ForEach(listener => listener.OnPrintManualRefundReceipt(pmrrm));
break;
}
case WebSocketMethod.PrintPaymentDeclinedReceipt:
{
PrintPaymentDeclineReceiptMessage ppdrm = JsonUtils.deserialize <PrintPaymentDeclineReceiptMessage>(payload.ToString());
listeners.ForEach(listener => listener.OnPrintPaymentDeclineReceipt(ppdrm));
break;
}
case WebSocketMethod.PrintPaymentMerchantCopyReceipt:
{
PrintPaymentMerchantCopyReceiptMessage ppmcrm = JsonUtils.deserialize <PrintPaymentMerchantCopyReceiptMessage>(payload.ToString());
listeners.ForEach(listener => listener.OnPrintPaymentMerchantCopyReceipt(ppmcrm));
break;
}
case WebSocketMethod.PrintPaymentReceipt:
{
PrintPaymentReceiptMessage pprm = JsonUtils.deserialize <PrintPaymentReceiptMessage>(payload.ToString());
listeners.ForEach(listener => listener.OnPrintPaymentReceipt(pprm));
break;
}
case WebSocketMethod.PrintPaymentRefundReceipt:
{
PrintRefundPaymentReceiptMessage prprm = JsonUtils.deserialize <PrintRefundPaymentReceiptMessage>(payload.ToString());
listeners.ForEach(listener => listener.OnPrintRefundPaymentReceipt(prprm));
break;
}
}
}
public override void OnConfirmPaymentRequest(ConfirmPaymentRequest request)
{
Connector.AcceptPayment(request.Payment);
}
public void OnConfirmPaymentRequest(ConfirmPaymentRequest request)
{
Send("/ConfirmPaymentRequest", Serialize(request));
}
public override void OnConfirmPaymentRequest(ConfirmPaymentRequest request)
{
}
public void OnConfirmPaymentRequest(ConfirmPaymentRequest p0)
{
}
public async Task <IActionResult> Stripe([FromBody] ConfirmPaymentRequest request)
{
var paymentIntentService = new PaymentIntentService();
PaymentIntent paymentIntent = null;
try
{
if (request.PaymentMethodId != null)
{
//Needed objects
var course = _courseService.GetCourse(request.CourseId);
var invoice = _paymentService.GetInvoice(request.InvoiceNumber);
var user = await _context.Users.FindAsync(_access.GetUserId(User));
var description = "";
// if (user == null)
// return BadRequest(new {result = EnumList.PaymentResult.Failed.ToString(), message = "error", courseId, invoiceNumber,reason = reason.ToString()});
//ToDo :: Handle the return of bad request
decimal amountToPay = 0;
switch (request.Reason)
{
case EnumList.PaymentReason.Register:
//Check if course null
if (course == null) // ToDo :: Handle bad request return
{
return(BadRequest(new { userId = user.Id, result = EnumList.PaymentResult.Failed.ToString(), message = "error", request.CourseId, request.InvoiceNumber, reason = request.Reason.ToString() }));
}
//Get on register invoice
var registerInvoice = _paymentService.CreateOnRegisterInvoices(request.CourseId, user)
.SingleOrDefault(x => x.Reason == EnumList.InvoiceReason.Registration);
//Determine the amount user wants to pay now
if (request.PayAllNow)
{
amountToPay = course.Price;
}
else
{
amountToPay = registerInvoice?.Amount ?? 0;
}
description = $"Charge for {user.FirstName} {user.LastName} - {user.Email} For Course {course.Subject}-{course.Code} Payment: {amountToPay} kr";
break;
case EnumList.PaymentReason.Invoice:
//Check if invoice is null
if (invoice == null || !invoice.ActiveInvoice())
{
return(BadRequest(new { userId = user.Id, result = EnumList.PaymentResult.Failed.ToString(), message = "error", request.CourseId, request.InvoiceNumber, reason = request.Reason.ToString() }));
}
amountToPay = invoice.CurrentAmount;
description = $"Betaling av {user.FirstName} {user.LastName} - Fakturanummer: {invoice.Number} - KID-nummer: {invoice.CIDNumber}";
break;
case EnumList.PaymentReason.Empty:
case EnumList.PaymentReason.Donate:
case EnumList.PaymentReason.Other:
default:
return(BadRequest(new { userId = user.Id, result = EnumList.PaymentResult.Failed.ToString(), message = "error", request.CourseId, request.InvoiceNumber, reason = request.Reason.ToString() }));
}
//ToDo :: If amount to pay is 0 return Bad Request
var customerOptions = new CustomerCreateOptions
{
Description = $"{user.FirstName +" "+ user.LastName}",
Name = $"{user.FirstName +" "+ user.LastName}",
PaymentMethod = request.PaymentMethodId,
Email = $"{user.Email}",
Metadata = new Dictionary <string, string>
{
{ "UniqueId", $"USERID-{user.Id}-COURSE-{course.Id}-{Format.NorwayDateTimeNow().Year}" }
}
};
var customerService = new CustomerService();
var customer = customerService.Create(customerOptions);
// Create the PaymentIntent
var createOptions = new PaymentIntentCreateOptions
{
Amount = (int)amountToPay * 100,
Currency = "nok",
Description = description,
Customer = customer.Id,
ReceiptEmail = $"{user.Email}",
PaymentMethod = request.PaymentMethodId,
ConfirmationMethod = "manual",
Confirm = true,
};
paymentIntent = paymentIntentService.Create(createOptions);
var initiatedOrder = new InitiatedOrder
{
Id = paymentIntent.Id, User = user, CourseId = request.CourseId, InvoiceNumber = request.InvoiceNumber,
Amount = amountToPay, PaymentMethod = EnumList.PaymentMethod.Stripe, Reason = request.Reason, Status = EnumList.OrderStatus.Initiated,
Ip = request.Ip, OperatingSystem = request.OperatingSystem, DeviceType = request.DeviceType, AuthCookies = request.AuthCookies, PayAllNow = request.PayAllNow
};
await _context.AddAsync(initiatedOrder);
await _context.SaveChangesAsync();
}
if (request.PaymentIntentId != null)
{
var confirmOptions = new PaymentIntentConfirmOptions {
};
paymentIntent = paymentIntentService.Confirm(
request.PaymentIntentId,
confirmOptions
);
}
}
catch (StripeException e)
{
return(Json(new { error = e.StripeError.Message }));
}
return(GeneratePaymentResponse(paymentIntent));
}
/// <summary>
/// Handle OnConfirmPaymentRequest to decide whether an otherwise valid payment from the user should be accepted or rejected:
/// For example: The payment may be a duplicate payment
/// The payment device may have lost connection with the payment server and be in offline mode (store process payments later)
///
/// Here is where business logic like "accept payments under $10 even if offline, but reject larger payments" can be called.
/// Or the Point of Sale application may propmt the user/cashier in some circumstances.
/// This allows a business to manage their risk of nonpayment and return - some payment processing and banking agreements handle
/// fraud responsibility differently in some of these circumstances.
///
/// </summary>
public override void OnConfirmPaymentRequest(ConfirmPaymentRequest request)
{
// For simplicity in this sample, accept all payments (Duplicate and Offline)
cloverConnector.AcceptPayment(request.Payment);
}
public void OnConfirmPaymentRequest(ConfirmPaymentRequest request) => ConfirmPaymentRequest?.Invoke(this, request);
public string confirmPayment(ConfirmPaymentRequest request)
{
return(this.send(request));
}
public void OnConfirmPaymentRequest(ConfirmPaymentRequest request)
{
Program.WriteLine(MethodBase.GetCurrentMethod().Name);
Program.WriteLine("Accepting Payment");
Pos.Connector.AcceptPayment(request.Payment);
}
public void OnConfirmPaymentRequest(ConfirmPaymentRequest request)
{
}
public IActionResult PerformTransaction([FromBody] ConfirmPaymentRequest request)
{
if (!request.ValidateObject())
{
try
{
ExceptionHandeling.FireError((int)ErrorCode.General_Error, (int)GeneralError.Nullable_Request, Constants.Constants.GeneralErrorDic[GeneralError.Nullable_Request]);
}
catch (CodeLabException codelabExp)
{
return(ExceptionHandeling.GenerateErrorResponse(codelabExp));
}
}
ConfirmPaymentResponse response = new ConfirmPaymentResponse();
AccountRep accountRep = new AccountRep(Context);
Account fromWallet = accountRep.GetByMSDIN(request.BasicInfo.MobileNumberInfo.Number);
Account toWallet = accountRep.GetByMSDIN(request.ToWalletNumber);
decimal totalAmount = (decimal)request.TotalAmount;
string DecodedMPIN = "";
try
{
byte[] data = Convert.FromBase64String(request.MPin);
DecodedMPIN = Encoding.UTF8.GetString(data);
}
catch (Exception ex)
{
DecodedMPIN = "";
}
try
{
if (fromWallet != null && toWallet != null)
{
if (fromWallet == toWallet)
{
ExceptionHandeling.FireError((int)ErrorCode.Payment_Error, (int)PaymentError.Same_From_To_Wallet, Constants.Constants.PaymentErrorDic[PaymentError.Same_From_To_Wallet]);
}
if (fromWallet.Mpin == DecodedMPIN)
{
if (toWallet.Balance >= totalAmount)
{
if (request.TotalAmount <= Constants.Constants.MaxLimit)
{
if (request.TotalAmount >= Constants.Constants.MinLimit)
{
fromWallet.Balance -= totalAmount;
toWallet.Balance += totalAmount;
accountRep.Update(fromWallet);
accountRep.Update(toWallet);
//insert Transaction
Transaction transaction = new Transaction()
{
TransactionId = request.TransactionId,
FromAccount = fromWallet.Id,
ToAccount = toWallet.Id,
Status = 2,
IssueTime = DateTime.Now,
LastUpdateTime = DateTime.Now,
Amount = totalAmount,
CurrencyCode = request.CurrencyCode
};
TransactionRep transactionRep = new TransactionRep(Context);
transactionRep.InsertTransaction(transaction);
response.TransactionStatus = 1;
response.AdditionalInfo = "string information" + "\n" + "Basic Info:" + request.BasicInfo.ToString();;
response.TransactionId = request.TransactionId;
response.CurrentBalance = (double)fromWallet.Balance;
response.CompletionDateTime = transaction.IssueTime.ToString(Constants.Constants.DateTimeFormat);
response.TotalAmount = (double)transaction.Amount;
response.CurrencyCode = transaction.CurrencyCode;
}
else
{
ExceptionHandeling.FireError((int)ErrorCode.Payment_Error, (int)PaymentError.Less_Than_Min_Amount, Constants.Constants.PaymentErrorDic[PaymentError.Less_Than_Min_Amount]);
}
}
else
{
ExceptionHandeling.FireError((int)ErrorCode.Payment_Error, (int)PaymentError.Greater_Than_Max_Amount, Constants.Constants.PaymentErrorDic[PaymentError.Greater_Than_Max_Amount]);
}
}
else
{
ExceptionHandeling.FireError((int)ErrorCode.Payment_Error, (int)PaymentError.Insufficient_Balance, Constants.Constants.PaymentErrorDic[PaymentError.Insufficient_Balance]);
}
}
else
{
ExceptionHandeling.FireError((int)ErrorCode.Wrong_Input_Error, (int)WrongInputError.Wrong_MPIN, Constants.Constants.WrongInputDic[WrongInputError.Wrong_MPIN]);
}
}
else
{
ExceptionHandeling.FireError((int)ErrorCode.Wrong_Input_Error, (int)WrongInputError.Wrong_Wallet_Number, Constants.Constants.WrongInputDic[WrongInputError.Wrong_Wallet_Number]);
}
}
catch (CodeLabException codelabExp)
{
return(ExceptionHandeling.GenerateErrorResponse(codelabExp));
}
return(Ok(response));
}
public async Task <ActionResult> ConfirmPaymentAsync([FromBody] ConfirmPaymentRequest request) => Ok(await zohoService.ConfirmPaymentAsync(request));
