// -------------------------------------------------------------
public string ShowCheckoutWindowAsync(
PaddleProductID productID,
CheckoutOptions options,
bool openInBrowser,
bool isDialog)
{
ScTask task = new ScTask();
PaddleProduct product = Paddle_GetProduct(productID);
product.Refresh((success) => {
#if kUseThreads
// do on another thread
i_threadData.i_currentWindowType = (PaddleWindowType)PaddleWindowType.Checkout;
i_threadData.i_currentProduct = product;
i_threadData.i_checkoutOptions = options;
i_threadData.i_openInBrowser = openInBrowser;
i_threadData.i_isDialog = isDialog;
StartWindowThread();
#else
// do it on this thread
Paddle.Instance.ShowCheckoutWindowForProduct(product, options, openInBrowser, isDialog);
#endif
});
return(task.await_result());
}
//-------------------------------------------------------------------
private string Purchase(string jsonCmd)
{
string jsonResult = "";
JObject cmdObject = JObject.Parse(jsonCmd);
PaddleProductID prodID = cmdObject.Value <PaddleProductID>(kPaddleCmdKey_SKU);
string emailStr = cmdObject.Value <string>(kPaddleCmdKey_EMAIL);
string couponStr = cmdObject.Value <string>(kPaddleCmdKey_COUPON);
string countryStr = cmdObject.Value <string>(kPaddleCmdKey_COUNTRY);
string postStr = cmdObject.Value <string>(kPaddleCmdKey_POSTCODE);
string titleStr = cmdObject.Value <string>(kPaddleCmdKey_TITLE);
string messageStr = cmdObject.Value <string>(kPaddleCmdKey_MESSAGE);
CheckoutOptions checkoutOptions = new CheckoutOptions {
Email = emailStr,
Coupon = couponStr,
Country = countryStr,
PostCode = postStr
};
// custom param keys are documented here:
// https://paddle.com/docs/api-custom-checkout/
checkoutOptions.AddCheckoutParameters("quantity_variable", "0");
checkoutOptions.AddCheckoutParameters("title", titleStr);
checkoutOptions.AddCheckoutParameters("custom_message", messageStr);
// documented here: https://paddle.com/docs/checkout-options-windows-sdk/
jsonResult = ShowCheckoutWindowAsync(prodID, checkoutOptions, false, true);
return(jsonResult);
}
public void CreateInstance(PaddleProductID productID)
{
string vendorStr = i_vendorID.ToString();
string productStr = productID.ToString();
// Initialize the SDK singleton with the config
Paddle.Configure(
i_apiKeyStr,
vendorStr,
productStr,
Paddle_GetConfig(productID));
Paddle.Instance.HighDpiMode = true;
Paddle.Instance.TransactionBeginEvent += Paddle_CheckoutBeginEvent;
Paddle.Instance.TransactionCompleteEvent += Paddle_CheckoutCompleteEvent;
Paddle.Instance.TransactionErrorEvent += Paddle_CheckoutErrorEvent;
Paddle.Instance.LicensingStarting += Paddle_LicensingBeginEvent;
Paddle.Instance.LicensingCompleteEvent += Paddle_LicensingCompleteEvent;
Paddle.Instance.LicensingErrorEvent += Paddle_LicensingErrorEvent;
Paddle.Instance.RecoveryCompleteEvent += Paddle_RecoveryCompleteEvent;
Paddle.Instance.RecoveryErrorEvent += Paddle_RecoveryErrorEvent;
RegisterEventListeners();
}
//-------------------------------------------------------------------
private string Activate(string jsonCmd)
{
string jsonResult = "";
JObject cmdObject = JObject.Parse(jsonCmd);
PaddleProductID prodID = cmdObject.Value <PaddleProductID>(kPaddleCmdKey_SKU);
string emailStr = cmdObject.Value <string>(kPaddleCmdKey_EMAIL);
string snStr = cmdObject.Value <string>(kPaddleCmdKey_SERIAL_NUMBER);
PaddleProduct product = Paddle_GetProduct(prodID);
ScTask task = new ScTask();
product.ActivateWithEmail(emailStr, snStr,
(PaddleSDK.Product.VerificationState verifyState, string resultStr) =>
{
ActivationState state = ConvertState_VerifyToActivate(verifyState);
CJsonResult jResult = new CJsonResult {
successB = state == ActivationState.Activated,
resultI = Convert.ToInt32(state),
errStr = resultStr
};
task.set_result(CreateJsonResult(jResult));
});
jsonResult = task.await_result();
return(jsonResult);
}
private PaddleProduct Paddle_GetProduct(PaddleProductID productID)
{
PaddleProduct product = PaddleProduct.CreateProduct(
productID.ToString(),
PaddleSDK.Product.ProductType.SDKProduct,
Paddle_GetConfig(productID));
product.CanForceExit = false;
return(product);
}
private PaddleProductRec GetProductRec(PaddleProductID prodID)
{
if (i_prodMap.ContainsKey(prodID))
{
return(i_prodMap[prodID]);
}
debug_print(String.Format("ERROR: GetProductRec: no product: {0}", prodID));
return(new PaddleProductRec());
}
private PaddleProductConfig Paddle_GetConfig(PaddleProductID prodID)
{
PaddleProductRec prodRec = GetProductRec(prodID);
PaddleProductConfig config = new PaddleProductConfig {
ProductName = prodRec.nameStr,
VendorName = i_vendorNameStr,
TrialType = PaddleSDK.Product.TrialType.None,
TrialText = prodRec.localizedTrialStr,
Currency = "USD",
ImagePath = ""
};
return(config);
}
private string Deactivate(string jsonCmd)
{
string jsonResult = "";
JObject cmdObject = JObject.Parse(jsonCmd);
PaddleProductID prodID = cmdObject.Value <PaddleProductID>(kPaddleCmdKey_SKU);
PaddleProduct product = Paddle_GetProduct(prodID);
ScTask task = new ScTask();
product.Deactivate(
(bool stateB, string resultStr) =>
{
CJsonResult jResult = new CJsonResult {
successB = stateB,
resultI = Convert.ToInt32(stateB),
errStr = resultStr
};
task.set_result(CreateJsonResult(jResult));
});
jsonResult = task.await_result();
return(jsonResult);
}
// -------------------------------------------------------------
// validate means verify
private string Validate(string jsonCmd)
{
string jsonResult;
JObject cmdObject = JObject.Parse(jsonCmd);
PaddleProductID prodID = cmdObject.Value <PaddleProductID>(kPaddleCmdKey_SKU);
PaddleProduct product = Paddle_GetProduct(prodID);
if (!product.Activated)
{
VerificationState state;
if (product.TrialDaysRemaining > 0)
{
state = VerificationState.Verified;
}
else
{
state = VerificationState.NoActivation;
}
CJsonResult jResult = new CJsonResult {
successB = state == VerificationState.Verified,
resultI = Convert.ToInt32(state)
};
jsonResult = CreateJsonResult(jResult);
}
else
{
DateTime lastSuccessDateT = product.LastSuccessfulVerifiedDate;
TimeSpan spanSinceSuccessT = DateTime.Now - lastSuccessDateT;
double hoursSinceSuccessT = spanSinceSuccessT.TotalHours;
// Verify the activation only if it's been a while.
if (hoursSinceSuccessT < 1)
{
CJsonResult jResult = new CJsonResult {
successB = true,
resultI = Convert.ToInt32(VerificationState.Verified)
};
// No need to verify. The product is activated. All's well.
jsonResult = CreateJsonResult(jResult);
}
else
{
ScTask task = new ScTask();
product.VerifyActivation(
(PaddleSDK.Product.VerificationState in_state, string resultStr) =>
{
VerificationState state = (VerificationState)in_state;
bool destroyB = false;
switch (state)
{
case VerificationState.Unverified: {
// The activation is no longer valid. Destroy it, let the user know and continue with
// the trial.
destroyB = true;
} break;
case VerificationState.UnableToVerify: {
// Verify that the last successful verify date is valid.
// And then implement a cooldown strategy.
// Ensure that the last successful verified date appears valid.
// As `compare:` "detects sub-second differences" the dates should not be the same.
// Equally we can't have verified the activation in the future.
// future dates have a negative time span since now:
if (hoursSinceSuccessT < 0)
{
// The last successfully verified date does not seem valid. If the time difference
// is less than 24 hours, a timezone change is possible. Other than that, tampering
// seems likely.
//
// In doubt, destroy the activation and ask the user to reactivate.
destroyB = true;
}
// Implement a cooldown period: if the user has not gone online within the period,
// then destroy the activation and ask them to go online to re-activate.
double daysSinceSuccessT = spanSinceSuccessT.TotalDays;
if (daysSinceSuccessT >= 30)
{
destroyB = true;
}
else
{
// The grace period continues, so the user can continue to use the core functionality.
state = VerificationState.Verified;
}
} break;
}
if (destroyB)
{
product.DestroyActivation();
state = VerificationState.Unverified;
}
CJsonResult jResult = new CJsonResult {
successB = state == VerificationState.Verified,
resultI = Convert.ToInt32(state),
errStr = resultStr
};
task.set_result(CreateJsonResult(jResult));
});
jsonResult = task.await_result();
}
}
return(jsonResult);
}
public void AddProduct(PaddleProductID prodID, string nameStr, string localizedTrialStr)
{
i_prodMap[prodID] = new PaddleProductRec(nameStr, localizedTrialStr);
}
