private bool CreateNewStripeCustomer(string email, string token, int quantity, UserInfo userInfo)
{
//create new customer
var myCustomer = new StripeCustomerCreateOptions();
myCustomer.Email = email;
myCustomer.TokenId = token;
myCustomer.PlanId = Constants.StripeSubscriptionPlan;
myCustomer.Quantity = quantity;
var customerService = new StripeCustomerService();
try
{
StripeCustomer stripeCustomer = customerService.Create(myCustomer);
//save profile ID and profile status with user info
userInfo.Subscribed = true;
userInfo.PaymentCustomerId = stripeCustomer.Id;
userInfo.PaymentCustomerStatus = stripeCustomer.StripeSubscription.Status;
db.Entry(userInfo).State = EntityState.Modified;
}
catch (Exception e)
{
Utilities.LogAppError("Create/Subscribe failed: " + e.Message);
return(false);
}
return(true);
}
public async Task WhenStripeModeIsLive_ItShouldCreateACustomer()
{
this.apiKeyRepository.Setup(v => v.GetApiKey(UserType.StandardUser)).Returns(LiveKey);
var expectedOptions = new StripeCustomerCreateOptions
{
Description = UserId.ToString(),
Source = new StripeSourceOptions
{
TokenId = TokenId,
}
};
var customer = new StripeCustomer {
Id = CustomerId
};
this.stripeService.Setup(v => v.CreateCustomerAsync(
It.Is <StripeCustomerCreateOptions>(
x => JsonConvert.SerializeObject(x, Formatting.None) == JsonConvert.SerializeObject(expectedOptions, Formatting.None)),
LiveKey))
.ReturnsAsync(customer);
var result = await this.target.ExecuteAsync(UserId, TokenId, UserType.StandardUser);
Assert.AreEqual(CustomerId, result);
}
static void TestInvoices2(StripePayment payment)
{
StripeCustomer cust = payment.GetCustomer("cus_ulcOcy5Seu2dpq");
StripePlanInfo planInfo = new StripePlanInfo {
Amount = 1999,
ID = "testplan",
Interval = StripePlanInterval.Month,
Name = "The Test Plan",
//TrialPeriod = 7
};
//payment.DeletePlan (planInfo.ID);
StripePlan plan = payment.CreatePlan(planInfo);
StripeSubscriptionInfo subInfo = new StripeSubscriptionInfo {
Card = GetCC(),
Plan = planInfo.ID,
Prorate = true
};
StripeSubscription sub = payment.Subscribe(cust.ID, subInfo);
payment.CreateInvoiceItem(new StripeInvoiceItemInfo {
CustomerID = cust.ID,
Amount = 1337,
Description = "Test single charge"
});
var invoices = payment.GetInvoices(0, 10, cust.ID);
StripeInvoice upcoming = payment.GetUpcomingInvoice(cust.ID);
payment.Unsubscribe(cust.ID, true);
payment.DeletePlan(planInfo.ID);
foreach (StripeLineItem line in upcoming)
{
Console.WriteLine("{0} for type {1}", line.Amount, line.GetType());
}
}
public ActionResult Index(string jsonCardInformation)
{
JObject jObject = JObject.Parse(jsonCardInformation);
string key = ConfigurationManager.AppSettings["StripeSecretKey"];
var myCustomer = new StripeCustomerCreateOptions();
myCustomer.Email = System.Web.HttpContext.Current.User.Identity.Name;
myCustomer.Description = "Testing a Card";
myCustomer.SourceToken = jObject["tokenId"].ToString();
var customerService = new StripeCustomerService();
StripeRequestOptions requestOption = new StripeRequestOptions()
{
ApiKey = key
};
StripeCustomer stripeCustomer = new StripeCustomer();
stripeCustomer = customerService.Create(myCustomer, requestOption);
CardInfo newCustomer = new CardInfo()
{
CustomerId = stripeCustomer.Id,
Email = System.Web.HttpContext.Current.User.Identity.Name,
Name = jObject["name"].ToString(),
CardType = jObject["cardBrand"].ToString(),
LastFour = jObject["lastFour"].ToString()
};
ctx.Cards.Add(newCustomer);
ctx.SaveChanges();
var x = ctx.Cards.Where(y => y.Email == System.Web.HttpContext.Current.User.Identity.Name);
return(View(x));
}
/// <summary>
/// Gets the default card associated with this customer
/// </summary>
/// <param name="customer"></param>
/// <returns></returns>
public static StripeCard GetDefaultCard(this StripeCustomer customer)
{
if (customer.StripeDefaultCard != null)
{
return(customer.StripeDefaultCard);
}
if (string.IsNullOrEmpty(customer.StripeDefaultCardId))
{
return(null);
}
if (customer.StripeCardList == null)
{
return(null);
}
foreach (StripeCard card in customer.StripeCardList.StripeCards)
{
if (card.Id == customer.StripeDefaultCardId)
{
return(card);
}
}
return(null);
}
public StripeCustomer CreateStripeCustomer(string sEmail, string sToken, string sInputDiscountCode)
{
try
{
StripeConfiguration.SetApiKey(ConfigurationManager.AppSettings["stripeApi_LiveKey"]);
var customerService = new StripeCustomerService();
string sDiscountCode = ConfigurationManager.AppSettings["discount_code"];
var CustomerOptions = new StripeCustomerCreateOptions()
{
Email = sEmail,
Description = "EmediCodes Basic Plan for " + sEmail,
AccountBalance = 0,
PlanId = "1",
SourceToken = sToken,
TrialEnd = DateTime.Now + TimeSpan.FromDays(14)
};
if (sInputDiscountCode.Equals(sDiscountCode))
{
CustomerOptions.CouponId = sDiscountCode;
}
StripeCustomer customer = customerService.Create(CustomerOptions);
return(customer);
}
catch (Exception ex)
{
oLogger.LogData("METHOD: CreateStripeCustomer; ERROR: TRUE; EXCEPTION: " + ex.Message + "; INNER EXCEPTION: " + ex.InnerException + "; STACKTRACE: " + ex.StackTrace);
throw;
}
}
/// <summary>
/// Retrieves the StripeCustomer associated with the given IStripeUser instance
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public static StripeCustomer RetrieveCustomer(IStripeUser user)
{
var customerService = new StripeCustomerService();
StripeCustomer stripeCustomer = customerService.Get(user.PaymentSystemId);
return(stripeCustomer);
}
protected void Button1_Click(object sender, EventArgs e)
{
try
{
StripeCustomer current = GetCustomer();
// int? days = getaTraildays();
//if (days != null)
//{
int chargetotal = 500;//Convert.ToInt32((3.33*Convert.ToInt32(days)*100));
var mycharge = new StripeChargeCreateOptions();
mycharge.Amount = chargetotal;
mycharge.Currency = "USD";
mycharge.CustomerId = current.Id;
string key = "sk_test_5jzcBuYhyxAk08sB8mT7KL43";
var chargeservice = new StripeChargeService(key);
StripeCharge currentcharge = chargeservice.Create(mycharge);
error.Visible = true;
error.InnerText = "La transacción se realizo con éxito";
}
catch (StripeException ex)
{
error.Visible = true;
error.InnerText = ex.Message;
}
catch
{
error.Visible = true;
error.InnerText = "Error en la transacción";
}
//}
}
/// <summary>
/// Gets the default card associated with this customer
/// </summary>
/// <param name="customer"></param>
/// <returns></returns>
public static StripeCard GetDefaultSource(this StripeCustomer customer)
{
if (customer.DefaultSource != null)
{
return(customer.DefaultSource);
}
if (string.IsNullOrEmpty(customer.DefaultSourceId))
{
return(null);
}
if (customer.SourceList == null || customer.SourceList.Data == null)
{
return(null);
}
foreach (StripeCard card in customer.SourceList.Data)
{
if (card.Id == customer.DefaultSourceId)
{
return(card);
}
}
return(null);
}
public string CreateCustomerObject(CustomerObjectRequest cardTokenRequest)
{
var customerCreateOptions = new StripeCustomerCreateOptions();
customerCreateOptions.TokenId = cardTokenRequest.CardToken;
//these are all optional
customerCreateOptions.Email = "*****@*****.**";
customerCreateOptions.Description = "I am a tasty customer";
var metaData = new Dictionary <string, string>();
metaData.Add("opentableId", "123456");
customerCreateOptions.Metadata = metaData;
var customerService = new StripeCustomerService(ConfigurationManager.AppSettings["masterMerchantSecretkey"]);
try
{
StripeCustomer createdCustomer = customerService.Create(customerCreateOptions);
return(createdCustomer.Id);
}
catch (StripeException sx)
{
//do some logging
}
return("");
}
private StripeCustomer GetCustomerById(string customerId)
{
var customerService = new StripeCustomerService();
StripeCustomer stripeCustomer = customerService.Get(customerId);
return(stripeCustomer);
}
public ActionResult SubmitStripeSubscriptionForm(StripeSubscriptionCheckout model)
{
if (ModelState.IsValid)
{
var loggedOnMember = Members.GetCurrentMember();
var memberService = Services.MemberService;
var member = memberService.GetById(loggedOnMember.Id);
var customer = new StripeCustomerCreateOptions();
customer.Email = member.Email;
customer.Description = member.Name;
customer.SourceToken = model.StripeToken;
customer.PlanId = model.PlanId;
try
{
var customerService = new StripeCustomerService(SensativeInformation.StripeKeys.SecretKey);
StripeCustomer stripeCustomer = customerService.Create(customer);
//Log customer id on member
member.SetValue("stripeUserId", stripeCustomer.Id);
memberService.Save(member);
return(RedirectToCurrentUmbracoPage());
}
catch (StripeException e)
{
_log.Error(e.StripeError.Message);
ModelState.AddModelError("",
"There was an error setting up your subscription. Please try again. If the issue persists please contact us");
}
}
return(CurrentUmbracoPage());
}
public StripePlan GetUserPlan(string customerId)
{
var customerService = new StripeCustomerService();
StripeCustomer stripeCustomer = customerService.Get(customerId);
return(stripeCustomer.Subscriptions.First().StripePlan);
}
public StripeSubscription CreateSubscription(PurchaseInformation info, string customerIdOfStripe)
{
try
{
var customer = new StripeCustomerUpdateOptions();
customer.SourceCard = new SourceCard()
{
Number = info.CC_number,
ExpirationYear = Convert.ToInt32(info.ExpireYear),
ExpirationMonth = Convert.ToInt32(info.ExpireMonth),
Cvc = info.CCVCode,
Name = info.NameOnCard
};
if (!string.IsNullOrEmpty(info.Coupon))
{
customer.Coupon = info.Coupon;
}
var customerService = new StripeCustomerService();
StripeCustomer stripeCustomer = customerService.Update(customerIdOfStripe, customer);
var subscriptionService = new StripeSubscriptionService();
StripeSubscription stripeSubscription = subscriptionService.Create(customerIdOfStripe, info.PlanId); // optional StripeSubscriptionCreateOptions
return(stripeSubscription);
}
catch (Exception ex)
{
throw ex;
}
}
public void TestCustomers()
{
// SUBSCRIBE
// Arrange
ICustomerEntity customer = CreateMockCustomer();
// Act
StripeManager.CreateCustomer(customer);
// Assert
Assert.IsNotNull(customer.PaymentSystemId);
// RETRIEVE
// Act
StripeCustomer stripeCustomer = StripeManager.RetrieveCustomer(customer);
// Assert
Assert.IsNotNull(stripeCustomer);
// UPDATE
// Arrange
customer.Email = "*****@*****.**";
// act
StripeCustomer updatedStripeCustomer = StripeManager.UpdateCustomer(customer);
// Assert
Assert.IsNotNull(updatedStripeCustomer);
}
public customers_fixture()
{
CustomerCreateOptionsWithShipping = new StripeCustomerCreateOptions
{
Email = "*****@*****.**",
SourceToken = "tok_visa",
Shipping = new StripeShippingOptions
{
Name = "Namey Namerson",
Line1 = "123 Main St",
Line2 = "Apt B",
Country = "USA",
State = "NC",
}
};
var service = new StripeCustomerService(Cache.ApiKey);
CustomerWithShipping = service.Create(CustomerCreateOptionsWithShipping);
CustomerUpdateOptionsWithShipping = new StripeCustomerUpdateOptions
{
Email = "*****@*****.**",
Shipping = CustomerCreateOptionsWithShipping.Shipping
};
CustomerUpdateOptionsWithShipping.Shipping.Phone = "8675309";
UpdatedCustomerWithShipping = service.Update(CustomerWithShipping.Id, CustomerUpdateOptionsWithShipping);
}
public ActionResult <SuccessResponse> UpdateStatus(UserUpdateStatusRequest model)
{
int sCode = 200;
BaseResponse response = null;
try
{
_adminService.UpdateStatus(model);
if (model.UserStatusId == 2)
{
StripeCustomer customer = _stripeService.GetStripeCustomerByUserId(model.Id);
if (customer.SubscriptionTypeId != 1)
{
_stripeService.CancelSubscription(customer.SubscriptionId);
_stripeService.UpdateCustomerSubscriptions(model.Id, "none", "none");
}
}
response = new SuccessResponse();
}
catch (Exception ex)
{
sCode = 500;
base.Logger.LogError(ex.ToString());
response = new ErrorResponse($"Generic Errors: { ex.Message }");
}
return(StatusCode(sCode, response));
}
public ActionResult Subscribe(StripeTokenResponse data)
{
var myCustomer = new StripeCustomerCreateOptions();
myCustomer.Email = User.Identity.Name;
myCustomer.SourceToken = data.StripeToken;
myCustomer.PlanId = ConfigurationManager.AppSettings["stripe:plan"]; // only if you have a plan
myCustomer.TaxPercent = 0; // only if you are passing a plan, this tax percent will be added to the price.
Metrics.Info($"Creating subscription for {myCustomer.Email} {myCustomer.SourceToken} {myCustomer.PlanId}");
var customerService = new StripeCustomerService(ConfigurationManager.AppSettings["stripe:token_secret"]);
StripeCustomer stripeCustomer = customerService.Create(myCustomer);
using (var db = new Email2SmsContext())
{
var userId = GetUserId();
var row = db.Subscriptions.FirstOrDefault(f => f.User == userId);
if (row == null)
{
row = new Subscription {
User = userId
};
db.Subscriptions.Add(row);
}
row.StripeCustomer = stripeCustomer.Id;
row.LastInvoiceUtc = DateTime.UtcNow;
db.SaveChanges();
}
return(Redirect("~/home/setup"));
}
public bool CheckCustomerPaymentMethod(string sStripeCustomerId)
{
try
{
StripeConfiguration.SetApiKey(ConfigurationManager.AppSettings["stripeApi_LiveKey"]);
bool blnPaymentMethodExists = false;
var customerService = new StripeCustomerService();
StripeCustomer customer = customerService.Get(sStripeCustomerId);
if (!customer.Sources.Any())
{
return(blnPaymentMethodExists);
}
else
{
blnPaymentMethodExists = true;
return(blnPaymentMethodExists);
}
}
catch (Exception ex)
{
oLogger.LogData("METHOD: CheckCustomerPaymentMethod; ERROR: TRUE; EXCEPTION: " + ex.Message + "; INNER EXCEPTION: " + ex.InnerException + "; STACKTRACE: " + ex.StackTrace);
throw;
}
}
/// <summary>
/// Creates a new customer record in Stripe for the given user
/// This will set the "PaymentSystemId" property on the given IStripeUser instance if the user was successfully created
/// NOTE: Save changes on the underlying context for the model after calling this method
/// </summary>
/// <param name="customer"></param>
/// <param name="paymentToken"></param>
public static StripeCustomer CreateCustomer(ICustomerEntity customer, string paymentToken = null)
{
// Do not overwrite the user, ever
if (customer.HasPaymentInfo())
{
return(null);
}
var newCustomer = new StripeCustomerCreateOptions();
newCustomer.Email = customer.Email;
if (paymentToken != null)
{
newCustomer.Source = new StripeSourceOptions()
{
TokenId = paymentToken
}
}
;
var customerService = new StripeCustomerService();
StripeCustomer stripeCustomer = customerService.Create(newCustomer);
// Set the accounting info
customer.PaymentSystemId = stripeCustomer.Id;
Logger.Log <StripeManager>("Created customer in stripe: '{0}' with id '{1}", LogLevel.Information, customer.Email, customer.PaymentSystemId);
return(stripeCustomer);
}
/// <summary>
/// Creates a new customer record in Stripe for the given user
/// NOTE: Save changes on the underlying context for the model after calling this method
/// </summary>
/// <param name="user"></param>
public static void CreateCustomer(IStripeUser user, string paymentToken = null)
{
// Do not overwrite the user, ever
if (user.HasPaymentInfo())
{
return;
}
var newCustomer = new StripeCustomerCreateOptions();
newCustomer.Email = user.Email;
if (paymentToken != null)
{
newCustomer.Card = new StripeCreditCardOptions()
{
TokenId = paymentToken
}
}
;
var customerService = new StripeCustomerService();
StripeCustomer stripeCustomer = customerService.Create(newCustomer);
// Set the accounting info
user.PaymentSystemId = stripeCustomer.Id;
System.Diagnostics.Trace.TraceInformation("Created customer in stripe: '{0}' with id '{1}", user.Email, user.PaymentSystemId);
}
private StripeCustomer createTCGStripeCustomer(StorePaymentMethod_Details details, string sourceToken)
{
StripeConfiguration.SetApiKey(secretKey);
StripeCustomer customer = new StripeCustomer();
try
{
StripeSource source = new StripeSource();
if (sourceToken == null)
{
source = createStripeSource(details.CardNumber, details.CardExpiryYear, details.CardExpiryMonth, details.CardCVV, details.CardHolderFullName, true);
}
else
{
source.Id = sourceToken;
}
//ATTACH THE SOURCE TO CUSTOMER
var customerOptions = new StripeCustomerCreateOptions()
{
SourceToken = source.Id
};
var customerService = new StripeCustomerService();
customer = customerService.Create(customerOptions);
}
catch (StripeException e)
{
throw new StripeException(e.HttpStatusCode, e.StripeError, e.Message);
}
return(customer);
}
public GetCustomerResponse GetCustomerInformation(string customerId)
{
var response = new GetCustomerResponse();
var customerService = new StripeCustomerService();
try
{
StripeCustomer stripeCustomer = customerService.Get(customerId);
MapStripeCustomerTo(stripeCustomer, response);
response.Success = true;
}
catch (StripeException ex)
{
response.Success = false;
response.Message = ex.Message;
return(response);
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
void IEmailHelper.SendSubscriptionCancelled(StripeCustomer customer, string customerEmail, string customerName)
{
Guard.ArgumentNotNullOrEmptyString(customerName, "customerName");
Guard.ArgumentNotNullOrEmptyString(customerEmail, "customerEmail");
Guard.ArgumentNotNull(() => customer);
Dictionary <string, string> values = new Dictionary <string, string>();
values.Add("FirstName", customerName);
values.Add("Date", customer.StripeSubscription.TrialEnd.ToString());
var send = this as IEmailHelper;
string fileName = String.Empty;
if (root.Contains("~"))
{
fileName = System.Web.HttpContext.Current.Server.MapPath(root + "SubscriptionCancelled.txt");
}
else
{
fileName = root + "SubscriptionCancelled.txt";
}
send.SetupEmail(values, customerEmail, fileName, "We Need You Have. Subscription Cancelled Notice.");
}
public bool Post([FromBody] JObject report)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("Username", report.Property("username").Value.ToString());
List <Subscription> sub = new Subscription().SearchDocument(parameters);
if (sub.Count <= 0)
{
StripeConfiguration.SetApiKey("sk_test_p9FWyo0hC9g8y39CkRR1pnYH");
var options = new StripeCustomerCreateOptions {
Email = report.Property("email").Value.ToString(),
SourceToken = report.Property("id").Value.ToString()
};
var service = new StripeCustomerService();
StripeCustomer customer = service.Create(options);
DoSub(customer, report);
}
else
{
updateSubscription(report);
}
return(true);
}
public static Customer ToCustomer(this StripeCustomer stripeCustomer)
{
var customer = new Customer
{
Id = stripeCustomer.Id,
Name = stripeCustomer.Description,
Email = stripeCustomer.Email,
DefaultSource = stripeCustomer.DefaultSourceId
};
if (stripeCustomer.Metadata != null)
{
if (stripeCustomer.Metadata.ContainsKey("Name"))
{
customer.Name = stripeCustomer.Metadata["Name"];
}
if (stripeCustomer.Metadata.ContainsKey("BusinessName"))
{
customer.BusinessName = stripeCustomer.Metadata["BusinessName"];
}
if (stripeCustomer.Metadata.ContainsKey("abn"))
{
customer.Abn = stripeCustomer.Metadata["abn"];
}
}
return(customer);
}
static void TestCreateInvoiceItems(StripePayment payment)
{
StripeCustomer cust = payment.CreateCustomer(new StripeCustomerInfo());
StripeInvoiceItemInfo info = GetInvoiceItemInfo();
info.CustomerID = cust.ID;
StripeInvoiceItem item = payment.CreateInvoiceItem(info);
StripeInvoiceItemInfo newInfo = GetInvoiceItemInfo();
newInfo.Description = "Invoice item: " + Guid.NewGuid().ToString();
StripeInvoiceItem item2 = payment.UpdateInvoiceItem(item.ID, newInfo);
StripeInvoiceItem item3 = payment.GetInvoiceItem(item2.ID);
if (item.Description == item3.Description)
{
throw new Exception("Update failed");
}
StripeInvoiceItem deleted = payment.DeleteInvoiceItem(item2.ID);
if (!deleted.Deleted.HasValue && deleted.Deleted.Value)
{
throw new Exception("Delete failed");
}
var items = payment.GetInvoiceItems(10, 10, null);
Console.WriteLine(items.Total);
payment.DeleteCustomer(cust.ID);
}
public void Create(string userName, Plan plan, string stripeToken)
{
//get User
var user = UserManager.FindByName(userName);
if (string.IsNullOrEmpty(user.StripeCustomerId)) //First Time customer
{
//create customer which will create subscription if plan is set and cc info via token is provided
var customer = new StripeCustomerCreateOptions()
{
Email = user.Email,
Source = new StripeSourceOptions()
{
TokenId = stripeToken
},
PlanId = plan.ExternalId //external id is Stripe plan id
};
StripeCustomer stripeCustomer = StripeCustomerService.Create(customer);
//update user
user.StripeCustomerId = stripeCustomer.Id;
user.ActiveUntil = DateTime.Now.AddDays((double)plan.TrialPeriodDays);
UserManager.Update(user);
}
else
{
//customer already exists, add subscription to customer
var stripeSubscription = StripeSubscriptionService.Create(user.StripeCustomerId, plan.ExternalId);
user.ActiveUntil = DateTime.Now.AddDays((double)plan.TrialPeriodDays);
UserManager.Update(user);
}
}
public StripeSubscription SubscribeToPlan(ApplicationUser dbUser, string stripeToken, string planToSubscribeTo)
{
StripeCustomer customer = CreateStripeCustomer(dbUser, stripeToken);
var currentSubscriptionId = String.Empty;
if (customer.Subscriptions != null && customer.Subscriptions.TotalCount > 0)
{
currentSubscriptionId = customer.Subscriptions.Data[0].Id;
}
var service = new StripeSubscriptionService();
StripeSubscription subscription = null;
if (String.IsNullOrEmpty(currentSubscriptionId))
{
subscription = AddNewUserSubscription(customer.Id, planToSubscribeTo, service, dbUser);
}
else if (!planToSubscribeTo.Contains("Free"))
{
subscription = UpdateUserSubscription(customer.Id, currentSubscriptionId, planToSubscribeTo, service, dbUser);
}
else
{
CancleCustomerSubscription(dbUser);
}
return(subscription);
}
CustomerPayment ISubscriptionService.SaveCustomer(string id, ApplicationModel.Billing.CustomerPayment payment)
{
//Save Subscription Need to check first active vs new here
var organization = this.organizationRepository.Find(payment.OrganizationId, null, null);
var customerService = new StripeCustomerService();
if (id != null && id != "null")
{
var myCustomer = InitializeUpdateCustomerOptions(payment);
StripeCustomer stripeCustomer = customerService.Update(id, myCustomer);
}
else
{
var myCustomer = InitializeCreateSubscriptionOptions(payment);
StripeCustomer stripeCustomer = customerService.Create(myCustomer);
id = stripeCustomer.StripeSubscription.CustomerId;
payment.CustomerId = id;
}
organization.Subscription.Status = SubscriptionStatus.ACTIVE;
organization.Subscription.CustomerBillingId = id;
if (!String.IsNullOrEmpty(payment.CardNumber))
{
organization.Subscription.ExpirationDate = payment.CardExpirationMonth + "/" + payment.CardExpirationYear;
organization.Subscription.Last4Digits = payment.CardNumber.Substring(payment.CardNumber.Length - 4, 4);
}
organization.Subscription.HasTrialed = true;
var svc = (ISubscriptionService)this;
svc.SaveSubscription(organization);
return(payment);
}