public override bool CheckSign()
{
var apiContext = Configuration.GetAPIContext();
string payerId = Request["PayerID"];//PayPal生成
string paymentId = Request["paymentId"];
var paymentExecution = new PaymentExecution()
{
payer_id = payerId
};
var payment = new Payment()
{
id = paymentId
};
//查询目标订单
executedPayment = payment.Execute(apiContext, paymentExecution);
//检测 invoice_number==Payno,state==completed
//throw new Exception(JsonConvert.SerializeObject(executedPayment));
//ZLLog.L(ZoomLa.Model.ZLEnum.Log.pay,JsonConvert.SerializeObject(executedPayment));
string state = executedPayment.transactions[0].related_resources[0].sale.state;
if (state != "completed")
{
return(false);
}
else
{
return(true);
}
}
/// <summary>
/// Executes a PayPal payment.
/// </summary>
/// <returns>Capture string id.</returns>
public async Task <string> ExecutePaymentAsync()
{
APIContext apiContext = await this.GetAPIContextAsync();
try
{
Payment payment = new Payment()
{
id = this.paymentId
};
var paymentExecution = new PaymentExecution()
{
payer_id = this.payerId
};
var paymentResult = payment.Execute(apiContext, paymentExecution);
if (paymentResult.state.ToLowerInvariant() == "approved")
{
string authorizationCode = paymentResult.transactions[0].related_resources[0].authorization.id;
return(await Task.FromResult(authorizationCode));
}
}
catch (PayPalException ex)
{
this.ParsePayPalException(ex);
}
return(await Task.FromResult(string.Empty));
}
public void Checking()
{
while (true)
{
foreach (var gamePayment in payments.listOfPayments)
{
var id = gamePayment.Id;
var g = Payment.Get(apiContext, id);
if (g.payer != null)
{
if (g.state == "approved")
{
//gdy transakcja zostala wykonana przez paypala
//GamePacket packet = new GamePacket(OperationType.GET_CREDITS,gamePayment.Name);
//Connection.Send(packet);
}
else
{
//gdy transakcja zostaje zaakceptowana przez platnika
var paymentExecution = new PaymentExecution();
paymentExecution.payer_id = g.payer.payer_info.payer_id;
payment.Execute(apiContext, paymentExecution);
}
}
}
//PaymentExecution z = new PaymentExecution();
//payment.Execute(apiContext,)
Thread.Sleep(10000);
}
}
public async Task <bool> ExcutePayment(string paymentId, string payerID)
{
try
{
PaymentExecution paymentExecution = new PaymentExecution
{
PayerId = payerID
};
var paymentrespond = await this._paypalServices.ExecutePayment(paymentExecution, paymentId);
if (paymentrespond.State == "approved")
{
return(true);
}
return(false);
}
catch (Exception objEx)
{
Logging logging = new Logging();
logging.ErrorLogs(objEx.ToString());
return(false);
}
}
protected void btnConfirm_Click(object sender, EventArgs e)
{
var config = ConfigManager.Instance.GetProperties();
var accessToken = new OAuthTokenCredential(config).GetAccessToken();
var apiContext = new APIContext(accessToken);
var paymentId = Session["paymentId"].ToString();
if (!String.IsNullOrEmpty(paymentId))
{
var payment = new Payment()
{
id = paymentId
};
var payerId = Request.QueryString["PayerID"].ToString();
var paymentExecution = new PaymentExecution()
{
payer_id = payerId
};
var executedPayment = payment.Execute(apiContext, paymentExecution);
litInfo.Text = "<p>Your Order Has Been Completed</p>";
btnConfirm.Visible = false;
}
}
public static string ExecuteSale(string PaymentID, string PayerID)
{
try
{
string finalID = "";
Dictionary <string, string> payPalConfig = new Dictionary <string, string>();
payPalConfig.Add("mode", mode);
string AccessToken = GetPayPalAccessToken();
APIContext AC = new APIContext(AccessToken);
AC.Config = payPalConfig;
PaymentExecution pe = new PaymentExecution();
pe.payer_id = PayerID;
Payment p = new Payment();
p.id = PaymentID;
Payment pResp = p.Execute(AC, pe);
if (pResp.state.Equals("approved", StringComparison.OrdinalIgnoreCase))
{
finalID = pResp.id;
}
return(finalID);
}
catch (PayPal.PayPalException ppe)
{
Console.WriteLine(ppe);
throw ppe;
}
}
public float ExecutePayment(ExecutePaymentParam paymentParam)
{
try
{
APIContext apiContext = PaypalConfig.GetAPIContext();
var paymentExecution = new PaymentExecution()
{
payer_id = paymentParam.PayerId
};
payment = new Payment()
{
id = paymentParam.Session[paymentParam.Guid] as string
};
var executedPayment = payment.Execute(apiContext, paymentExecution);
if (executedPayment.state.ToLower() != "approved")
{
return(-1);
}
return(GetTotalMoney(executedPayment.transactions));
}
catch
{
return(-1);
}
}
public static async Task <Payment> ExecutePayment(string paymentId, string payerId)
{
var client = PayPalConfiguration.GetClient();
var paymentExecution = new PaymentExecution()
{
PayerId = payerId
};
var payment = new Payment()
{
Id = paymentId
};
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
request.RequestBody(paymentExecution);
try
{
//TODO - ASYNC
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
return(response.Result <Payment>());
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
throw httpException;
}
}
public void Execute(string paymentId, string payerId)
{
try
{
if (!tokens.ContainsKey(paymentId))
{
throw new DuradosException("There is no token in cache");
}
string token = tokens[paymentId];
string accessToken = "Bearer " + token;
APIContext apiContext = new APIContext(accessToken);
apiContext.Config = GetSdkConfig();
Payment payment = new Payment();
payment.id = paymentId;
PaymentExecution paymentExecution = new PaymentExecution();
paymentExecution.payer_id = payerId;
Payment executedPayment = payment.Execute(apiContext, paymentExecution);
tokens.Remove(paymentId);
UpdatePaymentLog(executedPayment);
}
catch (Exception exception)
{
throw new DuradosException("Failed to execute a paypal payment", exception);
}
}
protected override async Task <DonationResultModel> DoRefresh(string paymentId, DonationResultModel result, bool push)
{
var context = GetContext();
var payment = Payment.Get(context, paymentId);
if (payment != null)
{
if (push && payment.state == "created")
{
try
{
var payExecute = new PaymentExecution
{
payer_id = payment.payer?.payer_info?.payer_id,
transactions = payment.transactions
};
payment = Payment.Execute(context, paymentId, payExecute);
}
catch
{
result.Error = "An error has occurred trying to finalize your payment. Please try again later. " +
"You have not been charged";
}
}
result.PaymentId = payment.id;
result.PayerId = payment.payer?.payer_info?.payer_id;
result.TokenId = payment.token;
}
result.State = GetState(payment?.state);
return(result);
}
public static string ExecuteSale(string PaymentID, string PayerID)
{
string finalID = "";
Dictionary <string, string> payPalConfig = new Dictionary <string, string>();
payPalConfig.Add("mode", mode.ToString());
string AccessToken = GetPayPalAccessToken();
APIContext AC = new APIContext(AccessToken);
AC.Config = payPalConfig;
PaymentExecution pe = new PaymentExecution()
{
payer_id = PayerID
};
Payment p = new Payment()
{
id = PaymentID
};
Payment pResp = p.Execute(AC, pe);
if (pResp.state.Equals("approved", StringComparison.OrdinalIgnoreCase))
{
finalID = pResp.transactions[0].related_resources[0].sale.id;
}
return(finalID);
}
protected void btnComplete_Click(object sender, EventArgs e)
{
var config = ConfigManager.Instance.GetProperties();
var accessToken = new OAuthTokenCredential(config).GetAccessToken();
var apiContext = new APIContext(accessToken);
var paymentId = Session["paymentId"].ToString();
if (!String.IsNullOrEmpty(paymentId))
{
var payment = new Payment()
{
id = paymentId
}; //make payment object
var payerId = Request.QueryString["PayerID"].ToString();
var paymentExecution = new PaymentExecution()
{
payer_id = payerId
};
var executedPayment = payment.Execute(apiContext, paymentExecution);
btnComplete.Visible = false;
pnlCompleteShow.Visible = true;
pnlHead.Visible = false;
}
}
public async Task <Payment> ExecutePaymentAsync(PayVM payVM)
{
var paymentId = payVM.PaymentID;
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);
var body = new PaymentExecution()
{
PayerId = payVM.PayerID
};
request.RequestBody(body);
string ClientID = this.configuration.GetSection("ClientID").Get <string>();
string Secret = this.configuration.GetSection("Secret").Get <string>();
var environment = new SandboxEnvironment(ClientID, Secret);
var client = new PayPalHttpClient(environment);
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(result);
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
return(new Payment());
}
}
protected void btnConfirmPurchase_Click(object sender, EventArgs e)
{
var config = ConfigManager.Instance.GetProperties();
var accessToken = new OAuthTokenCredential(config).GetAccessToken();
var apiContext = new APIContext(accessToken);
var paymentId = Session["paymentId"].ToString();
if (!String.IsNullOrEmpty(paymentId))
{
var payment = new Payment()
{
id = paymentId
};
}
var payerId = Request.QueryString["PayerID"].ToString();
var paymentExecution = new PaymentExecution()
{
payer_id = payerId
};
litInformation.Text = "<p>Your order has been completed, Thank you</p>";
btnConfirmPurchase.Visible = false;
labelText.Visible = false;
}
public ActionResult Return(string payerId, string paymentId)
{
// Fetch the existing order
var order = _dbContext.Orders.FirstOrDefault(x => x.PayPalReference == paymentId);
// Get PayPal API Context using configuration from web.config
var apiContext = GetApiContext();
// Set the payer for the payment
var paymentExecution = new PaymentExecution()
{
payer_id = payerId
};
// Identify the payment to execute
var payment = new Payment()
{
id = paymentId
};
// Execute the Payment
var executedPayment = payment.Execute(apiContext, paymentExecution);
ClearCart();
return(RedirectToAction("Thankyou"));
}
public async Task <Payment> ExecutePayment(string payerId, string paymentId, string token)
{
var config = new Dictionary <string, string>();
config.Add("mode", this.configuration["Logging:Paypal:Mode"]);
config.Add("clientId", this.configuration["Logging:Paypal:ClientId"]);
config.Add("clientSecret", this.configuration["Logging:Paypal:ClientSecret"]);
var accessToken = new OAuthTokenCredential(config).GetAccessToken();
var apiContext = new APIContext(accessToken)
{
Config = config,
};
PaymentExecution paymentExecution = new PaymentExecution()
{
payer_id = payerId
};
Payment payment = new Payment()
{
id = paymentId
};
Payment executedPayment = await Task.Run(() => payment.Execute(apiContext, paymentExecution));
return(executedPayment);
}
public static TransactionResult ProcessExecution(Order order, PaymentReturnModel returnModel, PaypalWithRedirectSettings settings)
{
var transAmount = order.OrderTotal - order.StoreCreditAmount;
var payment = new PaymentExecution()
{
PayerId = returnModel.PayerId,
Transactions = new List <CartBase>()
{
new CartBase()
{
Amount = new Amount()
{
Currency = order.CurrencyCode,
Total = transAmount.ToString("N")
}
}
}
};
var pcRequest = new PaymentExecuteRequest(returnModel.PaymentId);
pcRequest.RequestBody(payment);
var environment = GetEnvironment(settings);
var client = new PayPalHttpClient(environment);
var transactionResult = new TransactionResult();
try
{
var response = client.Execute(pcRequest).Result;
var result = response.Result <Payment>();
transactionResult.Success = true;
transactionResult.NewStatus = result.State == "approved" ? PaymentStatus.Complete : PaymentStatus.OnHold;
transactionResult.OrderGuid = order.Guid;
transactionResult.TransactionAmount = result.Transactions[0].Amount.Total.GetDecimal();
transactionResult.TransactionGuid = returnModel.PaymentId;
transactionResult.TransactionCurrencyCode = result.Transactions[0].Amount.Currency;
transactionResult.ResponseParameters = new Dictionary <string, object>()
{
{ "id", result.Id },
{ "payerId", returnModel.PayerId },
{ "paymentId", returnModel.PaymentId },
{ "createTime", result.CreateTime },
{ "failureReason", result.FailureReason },
{ "experienceProfileId", result.ExperienceProfileId },
{ "noteToPayer", result.NoteToPayer },
{ "intent", result.Intent },
{ "state", result.State },
{ "updateTime", result.UpdateTime },
{ "saleId", result.Transactions[0].RelatedResources[0].Sale.Id }
};
}
catch (BraintreeHttp.HttpException ex)
{
transactionResult.Success = false;
transactionResult.Exception = ex;
}
return(transactionResult);
}
protected void btnConfirmPurchase_Click(object sender, EventArgs e)
{
var config = ConfigManager.Instance.GetProperties();
var accessToken = new OAuthTokenCredential(config).GetAccessToken();
var apiContext = new APIContext(accessToken);
var paymentId = Session["paymentId"].ToString();
if (!String.IsNullOrEmpty(paymentId))
{
//create a payment object with the paymentId from session
var payment = new Payment()
{
id = paymentId
};
var payerId = Request.QueryString["PayerID"].ToString();
var paymentExecution = new PaymentExecution()
{
payer_id = payerId
};
//execute the payments
var executedPayment = payment.Execute(apiContext, paymentExecution);
//inform the user
litInformation.Text = "<p>Your order has been completed</p>";
btnConfirmPurchase.Visible = false;
}
}
protected void Page_Load(object sender, EventArgs e)
{
var config = ConfigManager.Instance.GetProperties();
var accessToken = new OAuthTokenCredential(config).GetAccessToken();
var apiContext = new APIContext(accessToken);
var paymentId = Session["paymentId"].ToString();
if (!String.IsNullOrEmpty(paymentId))
{
var payment = new Payment()
{
id = paymentId
};
var payerId = Request.QueryString["PayerID"].ToString();
var paymentExecution = new PaymentExecution()
{
payer_id = payerId
};
var executePayment = payment.Execute(apiContext, paymentExecution);
litInformation.Text = "<p>Your order has been completed</p>";
}
}
public ActionResult ReturnTest(string token, string payerID, string paymentId)
{
////contact
//PayerInfo payInfo = new PayerInfo()
//{
// //billing_address = addr,
// //country_code= sCountryCode,
// first_name = sFirstName,
// last_name = sLastName,
// //middle_name ="",
// email = sEmail,
// //phone =sPhone,
//};
//Payer pyr = new Payer() { payer_info = payInfo };
// Get a reference to the config
var config = ConfigManager.Instance.GetProperties();
var accessToken = (string)Session["accesstoken"];
APIContext apiContext = new APIContext(accessToken);
apiContext.Config = config;
Payment payment = new Payment();
payment.id = paymentId;
//payment.payer = pyr;
PaymentExecution pymntExecution = new PaymentExecution();
pymntExecution.payer_id = payerID;
Payment executedPayment = payment.Execute(apiContext, pymntExecution);
return(View());
}
public async Task <Payment> ExecutePayment(PaymentExecution objPaymentExecution, string paymentId)
{
var client = new PayPalHttpClient(environment);
string intent = "sale";
PaymentExecuteRequest request = new PaymentExecuteRequest(paymentId);;
request.RequestBody(objPaymentExecution);
try
{
HttpResponse response = await client.Execute(request);
var statusCode = response.StatusCode;
Payment result = response.Result <Payment>();
return(result);
}
catch (Exception objException)
{
throw objException;
}
}
/// <summary>
/// Executes a PayPal payment.
/// </summary>
/// <returns>Capture string id.</returns>
public async Task <string> ExecutePaymentAsync()
{
APIContext apiContext = await this.GetAPIContextAsync().ConfigureAwait(false);
try
{
Payment payment = new Payment()
{
id = paymentId
};
PaymentExecution paymentExecution = new PaymentExecution()
{
payer_id = this.payerId
};
Payment paymentResult = payment.Execute(apiContext, paymentExecution);
if (paymentResult.state.Equals("approved", StringComparison.InvariantCultureIgnoreCase))
{
string authorizationCode = paymentResult.transactions[0].related_resources[0].authorization.id;
return(authorizationCode);
}
}
catch (PayPalException ex)
{
this.ParsePayPalException(ex);
}
return(string.Empty);
}
protected void BtnConfirmPurchase_Click(object sender, EventArgs e)
{
//Load values of items
string productId = Request.QueryString["ID"];
string quant = Request.QueryString["Quant"];
int stock = int.Parse(quant);
//Load paypal token
var config = ConfigManager.Instance.GetProperties();
var accessToken = new OAuthTokenCredential(config).GetAccessToken();
var apiContext = new APIContext(accessToken);
var paymentId = Session["paymentId"].ToString();
if (!String.IsNullOrEmpty(paymentId))
{
//create a payment object with the paymentId from session
var payment = new Payment()
{
id = paymentId
};
//retieve the payerId from the querystring and use it to create a new payment execution object
var payerId = Request.QueryString["PayerID"].ToString();
var paymentExecution = new PaymentExecution()
{
payer_id = payerId
};
//Execute the payment
var executedPayment = payment.Execute(apiContext, paymentExecution);
// Reduce Stock SQL code
// Code Adapted From JasonTsoum77, 2013
SqlConnection con = new
SqlConnection(ConfigurationManager.ConnectionStrings["IdentityConnectionString"].ToString());
string updateSQL = "UPDATE tblProducts SET Stock=Stock-" + stock + "Where ID=" + productId;
try
{
con.Open();
SqlCommand cmd = new SqlCommand(updateSQL, con);
SqlDataReader reader = cmd.ExecuteReader();
reader.Read();
DataTable dataTable = new DataTable();
dataTable.Load(reader);
}
finally
{
con.Close();
}
// End of Adapted Code
//Inform the user
litInformation.Text = "<p>Your order has been completed successfully!</p>";
btnConfirmPurchase.Visible = false;
btnCancelPurchase.Visible = false;
}
}
private Payment ExecutePayment(APIContext apiContext, string payerId, string paymentId)
{
PaymentExecution paymentExecution = new PaymentExecution();
paymentExecution.payer_id = payerId;
this.payment = new Payment();
payment.id = paymentId;
return(this.payment.Execute(apiContext, paymentExecution));
}
public void ExecutePayment(Payment payment)
{
PaymentExecution exe = new PaymentExecution();
payment = Payment.Get(this.Context, payment.id);
exe.payer_id = payment.payer.payer_info.payer_id;
payment = payment.Execute(this.Context, exe);
}
private PaymentExecution GetPaymentExecution()
{
List <Transactions> transactions = new List <Transactions>();
transactions.Add(GetTransactions());
PaymentExecution execution = new PaymentExecution();
execution.payer_id = GetPayerInfo().payer_id;
execution.transactions = transactions;
return(execution);
}
public void ExecutePayment(string payerId)
{
PaymentExecution exec = new PaymentExecution();
exec.payer_id = payerId;
Payment payment = new Payment();
Payment responsePayment = payment.Execute(credentials.AccessToken, new PaymentExecution());
WriteTestData("TestExecutePayment", responsePayment);
}
public PayPal.Api.Payment ExecutePayment(APIContext apiContext, string payerId, string paymentId)
{
var paymentExecution = new PaymentExecution {
payer_id = payerId
};
_payment = new PayPal.Api.Payment {
id = paymentId
};
return(_payment.Execute(apiContext, paymentExecution));
}
private Payment ExecutePayment(APIContext apiContext, string payerId, string paymentId)
{
var paymentExecution = new PaymentExecution {
payer_id = payerId
};
payment = new Payment {
id = paymentId
};
return(payment.Execute(apiContext, paymentExecution));
}
public static PaymentExecution GetPaymentExecution()
{
List <Transactions> transactions = new List <Transactions>();
transactions.Add(TransactionsTest.GetTransactions());
PaymentExecution execution = new PaymentExecution();
execution.payer_id = PayerInfoTest.GetPayerInfo().payer_id;
execution.transactions = transactions;
return(execution);
}
/// <summary>
/// Executes the payment and returns view with purchase information
/// </summary>
/// <param name="mod">model containing payment information</param>
/// <returns>View(model)</returns>
public ActionResult Complete(Purchase mod)
{
Purchase model = mod;
APIContext apiContext = GetAPIContext();
Payment pymnt = Payment.Get(apiContext, model.PaymentId);
PaymentExecution pymntExecution = new PaymentExecution();
pymntExecution.payer_id = model.PayerID;
Payment executedPayment = pymnt.Execute(apiContext, pymntExecution);
return View(model);
}
