public CapturePaymentResult Capture(CapturePaymentRequest capturePaymentRequest)
{
if (capturePaymentRequest == null)
{
throw new ArgumentNullException(nameof(capturePaymentRequest));
}
var currentStore = EngineContext.Current.Resolve <IStoreContext>().CurrentStore;
stripe.Charge charge = capturePaymentRequest.CreateCapture(this._stripePaymentSettings, currentStore);
if (charge.GetStatus() == StripeChargeStatus.Succeeded)
{
//successfully captured
return(new CapturePaymentResult
{
NewPaymentStatus = PaymentStatus.Paid,
CaptureTransactionId = charge.Id
});
}
else
{
//successfully captured
return(new CapturePaymentResult
{
Errors = new List <string>(new [] { $"An error occured attempting to capture charge {charge.Id}." }),
NewPaymentStatus = PaymentStatus.Authorized,
CaptureTransactionId = charge.Id
});
}
}
public static stripe.Charge CreateCapture(this CapturePaymentRequest capturePaymentRequest, StripePaymentSettings stripePaymentSettings, Store store)
{
var chargesService = new stripe.ChargeService(stripePaymentSettings.GetStripeClient());
var chargeId = capturePaymentRequest.Order.AuthorizationTransactionId;
stripe.Charge charge = chargesService.Capture(chargeId, new stripe.ChargeCaptureOptions()
{
StatementDescriptor = $"{store.Name.ToStripeDescriptor()}"
});
return(charge);
}
public static PaymentStatus GetPaymentStatus(this stripe.Charge charge, TransactionMode transactionMode)
{
switch (charge.GetStatus())
{
case StripeChargeStatus.Pending:
return(PaymentStatus.Pending);
case StripeChargeStatus.Succeeded:
return(transactionMode == TransactionMode.Authorize ? PaymentStatus.Authorized : PaymentStatus.Paid);
case StripeChargeStatus.Failed:
default:
throw new ArgumentOutOfRangeException("StripeStatus provided unknown.");
}
}
public static StripeChargeStatus GetStatus(this stripe.Charge charge)
{
switch (charge.Status)
{
case "succeeded":
return(StripeChargeStatus.Succeeded);
case "pending":
return(StripeChargeStatus.Pending);
case "failed":
return(StripeChargeStatus.Failed);
default:
throw new ArgumentOutOfRangeException("charge status unknown.");
}
}
public ViewResult makePayment(PaymentInformation cardInfo)
{
try
{
Stripe.StripeConfiguration.SetApiKey("sk_test_51HqI05B1UsJ4lZg1agboQSE7i0fWn98619xc2FP5NhREH4igqo1AlKTQO8VWMfsQBUs1OlXNBzBkOqORRQP6ZlPf00E2l0QVhL");
//Create Card Object to create Token
Stripe.CreditCardOptions card = new Stripe.CreditCardOptions();
card.Name = cardInfo.CardOwnerFirstName + " " + cardInfo.CardOwnerLastName;
card.Number = cardInfo.CardNumber;
card.ExpYear = cardInfo.ExpirationYear;
card.ExpMonth = cardInfo.ExpirationMonth;
card.Cvc = cardInfo.CVV2;
//Assign Card to Token Object and create Token
Stripe.TokenCreateOptions token = new Stripe.TokenCreateOptions();
token.Card = card;
Stripe.TokenService serviceToken = new Stripe.TokenService();
Stripe.Token newToken = serviceToken.Create(token);
Stripe.CustomerCreateOptions myCustomer = new Stripe.CustomerCreateOptions();
myCustomer.Email = cardInfo.Buyer_Email;
myCustomer.SourceToken = newToken.Id;
var customerService = new Stripe.CustomerService();
Stripe.Customer stripeCustomer = customerService.Create(myCustomer);
//Create Charge Object with details of Charge
var options = new Stripe.ChargeCreateOptions
{
Amount = Convert.ToInt32(cardInfo.Amount),
Currency = "USD",
ReceiptEmail = cardInfo.Buyer_Email,
CustomerId = stripeCustomer.Id,
};
//and Create Method of this object is doing the payment execution.
var service = new Stripe.ChargeService();
Stripe.Charge charge = service.Create(options); // This will do the Payment
return(View("Thanks"));
}
catch (StripeException e)
{
switch (e.StripeError.ErrorType)
{
case "card_error":
//error = ("Code: " + e.StripeError.Code + "; ");
error = (" Error Message: " + e.StripeError.Message);
break;
case "api_connection_error":
break;
case "api_error":
break;
case "authentication_error":
break;
case "invalid_request_error":
break;
case "rate_limit_error":
break;
case "validation_error":
break;
default:
// Unknown Error Type
break;
}
ViewBag.Greeting = error;
return(View("Error"));
}
}
public IActionResult ProcessPayment([FromBody] TransactionProcessParamsItems request, string PaymentType)
{
var requestParams = request.TransactionProcess;
Transactions model = new Transactions();
model.BackUrl = requestParams.BackUrl;
model.Currency = requestParams.Currency;
model.Description = requestParams.Description;
model.ID = requestParams.ID;
model.OrderAmount = requestParams.OrderAmount;
model.OrderId = requestParams.OrderId;
model.PaymentMethod = requestParams.PaymentMethod;
model.PaymentCardToken = requestParams.PaymentCardToken;
APIResponseData responseData = new APIResponseData();
responseData.StatusCode = 0;
responseData.Message = "Failed.";
if (model == null)
{
responseData.StatusCode = 2;
responseData.Message = "Value is required.";
goto skipToReturn;
}
try
{
var trans = _TransactionsService.GetTransactionById(model.ID.ToString());
if (trans == null)
{
responseData.Message = "Notfound.";
responseData.StatusCode = 2;
goto skipToReturn;
}
#region PAYPAL
if (PaymentType.ToUpper() == "PAYPAL") // Paypal
{
var paypal = Payment_PayPal(request);
trans.ModifiedDate = DateTime.Now;
trans.PaymentTypeAPI = PaymentType.ToUpper();
_TransactionsService.UpdateTransactions(trans);
responseData.Message = "Successfully.";
responseData.StatusCode = 1;
responseData.Result.Data = new
{
TransactionId = model.ID,
PaymenID = paypal.id,
PaymentStatus = paypal.state,
FailureMessage = paypal.failed_transactions
};
return(Ok(responseData));
//return new JsonResult(paypal);
}
#endregion
#region Stripe
else
{
Stripe.Charge charge = null;
//var amount = charge.Amount.ToString();
decimal payAmount = 0;
if (trans.PaymentMethod == Common.DTO.PaymentMethod.Full.ToUpper())
{
payAmount = model.OrderAmount.Value;
charge = StripeHelpers.RequestCharge(model, payAmount, model.Description);
trans.Status = charge.Status;
trans.ReferenceId = charge.Id;
}
else
{
var transactionItems = _TransactionsService.GetTransactionItems(trans.ID).ToList()
.Where(x => x.Status == null).OrderBy(x => x.OrderNo).ToList();
var nextPayItem = transactionItems.FirstOrDefault();
payAmount = nextPayItem.PayAmount.Value;
string description = string.Format("Charge {0}% of OrderId: {1}. {2}", nextPayItem.PayPercent, model.OrderId, model.Description);
charge = StripeHelpers.RequestCharge(model, payAmount, description);
nextPayItem.Status = charge.Status;
nextPayItem.ReferenceId = charge.Id;
_TransactionsService.UpdateTransactionItem(nextPayItem);
trans.Status = PaymentStatus.Processing;
}
trans.ModifiedDate = DateTime.Now;
trans.PaymentCardToken = model.PaymentCardToken;
trans.StripeCustomerId = charge.CustomerId;
trans.OrderAmountRemaining = trans.OrderAmountRemaining.Value - payAmount;
trans.PaymentTypeAPI = PaymentType.ToUpper();
_TransactionsService.UpdateTransactions(trans);
responseData.Message = "Successfully.";
responseData.StatusCode = 1;
responseData.Result.Data = new
{
TransactionId = model.ID,
PaymenID = charge.Id,
PaymentStatus = charge.Status,
FailureMessage = charge.FailureMessage
};
var PaymentLogs = new PaymentLogs()
{
Data = Newtonsoft.Json.JsonConvert.SerializeObject(charge),
Error = "Success",
PaymentType = PaymentType,
FunctionName = "ProcessPayment",
TransID = requestParams.ID.ToString()
};
_PaymentLogsService.InsertPaymentLogs(PaymentLogs);
}
#endregion
}
catch (Exception ex)
{
responseData.Message = "Something went wrong, please try again.";
responseData.StatusCode = 0;
var typeEx = ex.GetType();
if (typeEx.FullName == "PayPal.PayPalException")
{
var excep = ex as PayPal.PaymentsException;
StringBuilder sb = new StringBuilder();
sb.AppendLine("Error: " + excep.Details.name);
sb.AppendLine("Message: " + excep.Details.message);
sb.AppendLine("URI: " + excep.Details.information_link);
sb.AppendLine("Debug ID: " + excep.Details.debug_id);
foreach (var errorDetails in excep.Details.details)
{
sb.AppendLine("Details: " + errorDetails.field + " -> " + errorDetails.issue);
}
var PaymentLogs = new PaymentLogs()
{
Data = Newtonsoft.Json.JsonConvert.SerializeObject(request),
Error = sb.ToString(),
PaymentType = PaymentType,
FunctionName = "ProcessPayment",
TransID = requestParams.ID.ToString()
};
_PaymentLogsService.InsertPaymentLogs(PaymentLogs);
}
else
{
var PaymentLogs = new PaymentLogs()
{
Data = Newtonsoft.Json.JsonConvert.SerializeObject(request),
Error = ex.InnerException != null?Newtonsoft.Json.JsonConvert.SerializeObject(ex.InnerException.Message) : Newtonsoft.Json.JsonConvert.SerializeObject(ex.Message),
PaymentType = PaymentType,
FunctionName = "ProcessPayment",
TransID = requestParams.ID.ToString()
};
_PaymentLogsService.InsertPaymentLogs(PaymentLogs);
}
EmailHelpers.SendEmail(new Common.DTO.ErrorInfo()
{
Section = $"AQ ProcessPayment PaymentType: {PaymentType} <br /> TransactionID : {requestParams.ID}",
Exception = ex
});
}
skipToReturn: //label use to force return
return(Ok(responseData));
}
public ActionResult Charge(StripeChargeModel model)
{ // 4242424242424242
string errormessage = "";
bool isvalidemail = false;
bool isvalidamount = false;
HttpResponseMessage responseMessage = new HttpResponseMessage();
try
{
var addr = new System.Net.Mail.MailAddress(model.Email);
bool emailvalid = (addr.Address == model.Email);
isvalidemail = true;
}
catch
{
errormessage += "invalid email\r\n";
isvalidemail = false;
}
if (model.Amount == 0)
{
isvalidamount = false;
errormessage += "invalid amount\r\n";
}
else
{
isvalidamount = true;
}
if (isvalidamount == true && isvalidemail == true)
{
try
{
string Name = model.CardHolderName;
string CardNumber = model.CardNum;
long ExpirationYear = long.Parse(model.Expyear);
long ExpirationMonth = long.Parse(model.ExpMonth);
string CVV2 = model.CVV;
string Buyer_Email = model.Email;
int amount = (int)model.Amount;
Stripe.StripeConfiguration.SetApiKey("sk_test_KVelkjylnQQPOkrHSSu8gCft00dODAP1ie");
Stripe.CreditCardOptions card = new Stripe.CreditCardOptions();
card.Name = Name;
card.Number = CardNumber;
card.ExpYear = ExpirationYear;
card.ExpMonth = ExpirationMonth;
card.AddressLine1 = model.AddressLine1;
card.AddressLine2 = model.AddressLine2;
card.AddressState = model.AddressCity;
card.AddressCountry = model.AddressCountry;
card.AddressZip = model.AddressPostcode;
card.Cvc = CVV2;
// set card to token object and create token
Stripe.TokenCreateOptions tokenCreateOption = new Stripe.TokenCreateOptions();
tokenCreateOption.Card = card;
Stripe.TokenService tokenService = new Stripe.TokenService();
Stripe.Token token = tokenService.Create(tokenCreateOption);
//create customer object then register customer on Stripe
Stripe.CustomerCreateOptions customer = new Stripe.CustomerCreateOptions();
customer.Email = Buyer_Email;
var custService = new Stripe.CustomerService();
Stripe.Customer stpCustomer = custService.Create(customer);
//create credit card charge object with details of charge
var options = new Stripe.ChargeCreateOptions
{
Amount = (int)(amount * 100),
// Amount = (int)(model.Amount * 100),
// Currency = "gbp",
// Description = "Description for test charge",
// Source = model.Token
Currency = "gbp",
ReceiptEmail = Buyer_Email,
Source = model.Token,
Description = "Description for test charge"
};
//and Create Method of this object is doing the payment execution.
var service = new Stripe.ChargeService();
Stripe.Charge charge = service.Create(options); // This will do the Payment }
return(new HttpStatusCodeResult(HttpStatusCode.OK, "Success"));
}
catch
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "error : " + errormessage));
}
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "error : " + errormessage));
}
}
public ViewResult makePayment(PaymentInformation cardInfo)
{
try
{
Stripe.StripeConfiguration.SetApiKey("sk_test_51HqI05B1UsJ4lZg1agboQSE7i0fWn98619xc2FP5NhREH4igqo1AlKTQO8VWMfsQBUs1OlXNBzBkOqORRQP6ZlPf00E2l0QVhL");
Stripe.CreditCardOptions card = new Stripe.CreditCardOptions();
card.Name = cardInfo.CardOwnerFirstName + " " + cardInfo.CardOwnerLastName;
card.Number = cardInfo.CardNumber;
card.ExpYear = cardInfo.ExpirationYear;
card.ExpMonth = cardInfo.ExpirationMonth;
card.Cvc = cardInfo.CVV2;
Console.WriteLine(TotalPrice.ToString());
Stripe.TokenCreateOptions token = new Stripe.TokenCreateOptions();
token.Card = card;
Stripe.TokenService serviceToken = new Stripe.TokenService();
Stripe.Token newToken = serviceToken.Create(token);
Stripe.CustomerCreateOptions myCustomer = new Stripe.CustomerCreateOptions();
myCustomer.Email = cardInfo.Buyer_Email;
myCustomer.SourceToken = newToken.Id;
var customerService = new Stripe.CustomerService();
Stripe.Customer stripeCustomer = customerService.Create(myCustomer);
var t = TempData["totalCost"];
int t1 = (int)Math.Round(Convert.ToDouble(t)) - 1;
string total;
string input_decimal_number = t.ToString();
var regex = new System.Text.RegularExpressions.Regex("(?<=[\\.])[0-9]+");
if (regex.IsMatch(input_decimal_number))
{
string decimal_places = regex.Match(input_decimal_number).Value;
total = t1.ToString() + decimal_places;
}
else
{
total = t1 + "00";
}
System.Diagnostics.Trace.WriteLine(t1.ToString());
var options = new Stripe.ChargeCreateOptions
{
Amount = Convert.ToInt32(total),
Currency = "USD",
ReceiptEmail = cardInfo.Buyer_Email,
CustomerId = stripeCustomer.Id,
};
var service = new Stripe.ChargeService();
Stripe.Charge charge = service.Create(options);
return(View("Thanks"));
}
catch (StripeException e)
{
switch (e.StripeError.ErrorType)
{
case "card_error":
error = (" Error Message: " + e.StripeError.Message);
break;
case "api_connection_error":
break;
case "api_error":
break;
case "authentication_error":
break;
case "invalid_request_error":
break;
case "rate_limit_error":
break;
case "validation_error":
break;
default:
// Unknown Error Type
break;
}
ViewBag.Greeting = error;
return(View("Error"));
}
}
private async void Button_Clicked(object sender, EventArgs e)
{
try
{
StripeConfiguration.SetApiKey("sk_test_51H7Lu7KJ3FKVwUnlPU8EUYuDPU0UMWNajFeHpVYzqwLkpKFRk9480iV54ZvAIPy4J0xYlKoN9IQaGMoyhhcaxOgl003Kz8FIdL");
//This are the sample test data use MVVM bindings to send data to the ViewModel
Stripe.CreditCardOptions stripcard = new Stripe.CreditCardOptions();
stripcard.Number = cardNumberEntry.Text;
stripcard.ExpYear = Convert.ToInt32(expiryDate.Text.Split('/')[1]);
stripcard.ExpMonth = Convert.ToInt32(expiryDate.Text.Split('/')[0]);
stripcard.Cvc = cvvEntry.Text;
//Step 1 : Assign Card to Token Object and create Token
Stripe.TokenCreateOptions token = new Stripe.TokenCreateOptions();
token.Card = stripcard;
Stripe.TokenService serviceToken = new Stripe.TokenService();
Stripe.Token newToken = serviceToken.Create(token);
// Step 2 : Assign Token to the Source
var options = new SourceCreateOptions
{
Type = SourceType.Card,
Currency = "usd",
Token = newToken.Id
};
var service = new SourceService();
Source source = service.Create(options);
//Step 3 : Now generate the customer who is doing the payment
Stripe.CustomerCreateOptions myCustomer = new Stripe.CustomerCreateOptions()
{
Name = nameEntry.Text,
Email = emailEntry.Text,
Description = "Amare Payment",
};
var customerService = new Stripe.CustomerService();
Stripe.Customer stripeCustomer = customerService.Create(myCustomer);
mycustomer = stripeCustomer.Id; // Not needed
//Step 4 : Now Create Charge Options for the customer.
var chargeoptions = new Stripe.ChargeCreateOptions
{
Amount = 100,
Currency = "USD",
ReceiptEmail = emailEntry.Text,
Customer = stripeCustomer.Id,
Source = source.Id
};
//Step 5 : Perform the payment by Charging the customer with the payment.
var service1 = new Stripe.ChargeService();
Stripe.Charge charge = service1.Create(chargeoptions); // This will do the Payment
getchargedID = charge.Id; // Not needed
await DisplayAlert("Payment", "Payment Success", "Okay");
await Navigation.PopAsync();
}
catch (Stripe.StripeException ex)
{
await DisplayAlert("Payment Error", ex.Message, "Okay");
}
}
public PaymentView(DateTime bookingDate, string centerName, string sportName, string courtName, string startingBookingTime, string endingBookingTime, double TotalPaymentAmount)
{
InitializeComponent();
//startingBookingTime AND endingBookingTime are TimeSpan not DateTime ...... Done
var uname = Preferences.Get("UserName", String.Empty);
if (String.IsNullOrEmpty(uname))
{
username.Text = "Guest";
}
else
{
username.Text = uname;
}
centername.Text = centerName;
courtname.Text = courtName;
//bookingdate.Text = bookingDate.Date.ToString();
cvm = new PaymentViewModel(bookingDate);
this.BindingContext = cvm;
bookingtime.Text = startingBookingTime.ToString() + " - " + endingBookingTime.ToString();
double RoundedTotalPaymentAmount = Math.Round(TotalPaymentAmount, 1, MidpointRounding.ToEven);
totalpaymentamount.Text = "RM " + RoundedTotalPaymentAmount.ToString();
string totalp = totalpaymentamount.Text;
DateTime s = Convert.ToDateTime(startingBookingTime);
DateTime d = Convert.ToDateTime(endingBookingTime);
NewEventHandler.Clicked += async(sender, args) =>
{
// if check payment from Moustafa is true, then add booking to firebase
try
{
//StripeConfiguration.SetApiKey("sk_test_51IpayhGP2IgUXM55te5JbGRu14MOp6AU6GORVFhqpOilEOp96ERDzKCi1VN9rDLrOmOEwNPqgOvQuIyaNg8YKfkL00Qoq8a7QX");
StripeConfiguration.SetApiKey("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");
//This are the sample test data use MVVM bindings to send data to the ViewModel
Stripe.TokenCardOptions stripcard = new Stripe.TokenCardOptions();
stripcard.Number = cardnumber.Text;
stripcard.ExpYear = Int64.Parse(expiryYear.Text);
stripcard.ExpMonth = Int64.Parse(expirymonth.Text);
stripcard.Cvc = cvv.Text;
//stripcard.Cvc = Int64.Parse(cvv.Text);
//Step 1 : Assign Card to Token Object and create Token
Stripe.TokenCreateOptions token = new Stripe.TokenCreateOptions();
token.Card = stripcard;
Stripe.TokenService serviceToken = new Stripe.TokenService();
Stripe.Token newToken = serviceToken.Create(token);
// Step 2 : Assign Token to the Source
var options = new SourceCreateOptions
{
Type = SourceType.Card,
Currency = "myr",
Token = newToken.Id
};
var service = new SourceService();
Source source = service.Create(options);
//Step 3 : Now generate the customer who is doing the payment
Stripe.CustomerCreateOptions myCustomer = new Stripe.CustomerCreateOptions()
{
Name = "Moustafa",
Email = "*****@*****.**",
Description = "Customer for [email protected]",
};
var customerService = new Stripe.CustomerService();
Stripe.Customer stripeCustomer = customerService.Create(myCustomer);
mycustomer = stripeCustomer.Id; // Not needed
//Step 4 : Now Create Charge Options for the customer.
var chargeoptions = new Stripe.ChargeCreateOptions
{
//Amount = (Int64.Parse(RoundedTotalPaymentAmount)) * 100,
//(int(RoundedTotalPaymentAmount))
//Amount = Convert.ToInt32(RoundedTotalPaymentAmount) * 100,
//Amount = (long?)(double.Parse(RoundedTotalPaymentAmount) * 100),
Amount = (long?)(double.Parse(totalp) * 100),
Currency = "MYR",
ReceiptEmail = "*****@*****.**",
Customer = stripeCustomer.Id,
Source = source.Id
};
//Step 5 : Perform the payment by Charging the customer with the payment.
var service1 = new Stripe.ChargeService();
Stripe.Charge charge = service1.Create(chargeoptions); // This will do the Payment
getchargedID = charge.Id; // Not needed
}
catch (Exception ex)
{
UserDialogs.Instance.Alert(ex.Message, null, "ok");
Console.Write("error" + ex.Message);
//await Application.Current.MainPage.DisplayAlert("error ", ex.Message, "OK");
}
finally
{
//if (getchargedID != null)
if (getchargedID != null)
{
var acd = new AddBookingData(sportName, courtName, username.Text, centerName, s, d, bookingDate, RoundedTotalPaymentAmount);
await acd.AddBookingDataAsync();
UserDialogs.Instance.Alert("Payment Successed", "Success", "Ok");
Xamarin.Forms.Application.Current.MainPage = new MainTabbedView();
//await Application.Current.MainPage.DisplayAlert("Payment Successed ", "Success", "OK");
}
else
{
UserDialogs.Instance.Alert("Something Wrong", "Faild", "OK");
//await Application.Current.MainPage.DisplayAlert("Payment Error ", "faild", "OK");
}
}
/*
* var acd = new AddBookingData(sportName, courtName, username.Text, centerName, s, d, bookingDate, RoundedTotalPaymentAmount);
* await acd.AddBookingDataAsync();
* /*
*
*
* //Application.Current.MainPage = new MainTabbedView();
*
* //await Navigation.PopModalAsync();
* //await Navigation.PopToRootAsync();
* /*
* Navigation.InsertPageBefore(new NewPage(), Navigation.NavigationStack[0]);
* await Navigation.PopToRootAsync();
*/
};
/*
* public void GetCustomerInformationID(object sender, EventArgs e)
* {
* var service = new CustomerService();
* var customer = service.Get(mycustomer);
* var serializedCustomer = JsonConvert.SerializeObject(customer);
* // var UserDetails = JsonConvert.DeserializeObject<CustomerRetriveModel>(serializedCustomer);
*
* }
*
*
* public void GetAllCustomerInformation(object sender, EventArgs e)
* {
* var service = new CustomerService();
* var options = new CustomerListOptions
* {
* Limit = 3,
* };
* var customers = service.List(options);
* var serializedCustomer = JsonConvert.SerializeObject(customers);
* }
*
*
* public void GetRefundForSpecificTransaction(object sender, EventArgs e)
* {
* var refundService = new RefundService();
* var refundOptions = new RefundCreateOptions
* {
* Charge = getchargedID,
* };
* Refund refund = refundService.Create(refundOptions);
* refundID = refund.Id;
* }
*
*
* public void GetRefundInformation(object sender, EventArgs e)
* {
* var service = new RefundService();
* var refund = service.Get(refundID);
* var serializedCustomer = JsonConvert.SerializeObject(refund);
*
* }
*/
/*
*
* async Task NewEventHandler(object sender, EventArgs e)
* {
* // if check payment from Moustafa is true, then
*
* // add booking to firebase
*
* var acd = new AddBookingData(sportName, courtName, username.Text, centerName, s, d, bookingDate, TotalPaymentAmount);
* await acd.AddBookingDataAsync();
* }
*/
}