/// <summary>
/// Subscribes the user.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="planId">The plan identifier.</param>
/// <param name="trialEnds">The trial ends.</param>
/// <param name="taxPercent">The tax percent.</param>
public string SubscribeUser(SaasEcomUser user, string planId, DateTime?trialEnds, decimal taxPercent = 0)
{
var result = this._subscriptionService.Update(user.StripeCustomerId, planId,
new StripeSubscriptionUpdateOptions
{
PlanId = planId,
TaxPercent = taxPercent,
TrialEnd = trialEnds
});
return(result.Id);
}
/// <summary>
/// Subscribes the user.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="planId">The plan identifier.</param>
/// <param name="trialInDays">The trial in days.</param>
/// <param name="taxPercent">The tax percent.</param>
public string SubscribeUser(SaasEcomUser user, string planId, int trialInDays = 0, decimal taxPercent = 0)
{
var result = this._subscriptionService.Update(user.StripeCustomerId, planId,
new StripeSubscriptionUpdateOptions
{
PlanId = planId,
TaxPercent = taxPercent,
TrialEnd = DateTime.UtcNow.AddDays(trialInDays)
});
return(result.Id);
}
/// <summary>
/// Subscribes the user natural month asynchronous.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="planId">The plan identifier.</param>
/// <param name="card">The card.</param>
/// <param name="description">The description.</param>
/// <param name="taxPercent">The tax percent.</param>
/// <returns></returns>
public async Task <string> SubscribeUserNaturalMonthAsync(SaasEcomUser user,
string planId, CreditCard card, string description, decimal taxPercent = 0)
{
var trialEnds = GetStartNextMonth();
if (string.IsNullOrEmpty(user.StripeCustomerId))
{
// Create a new customer in Stripe and save card
var stripeUser = (StripeCustomer)await _customerProvider.CreateCustomerAsync
(user, null, trialEnds, card.StripeToken);
// Add subscription Id to the user
user.StripeCustomerId = stripeUser.Id;
await _cardDataService.AddAsync(card);
}
else if (!string.IsNullOrEmpty(card.StripeToken))
{
// Update the default card for the user
_customerProvider.UpdateCustomer(user, card);
card.SaasEcomUserId = user.Id;
await _cardDataService.AddOrUpdateDefaultCardAsync(user.Id, card);
}
// Create pro-rata charge for the remaining of the month
var amountInCents = await CalculateProRata(planId);
var planCurrency = await GetPlanCurrency(planId);
// If Charge succeeds -> Create Subscription
string error;
if (this._chargeProvider.CreateCharge(amountInCents, planCurrency, description, user.StripeCustomerId, out error))
{
// Create Subscription
var subscriptionId = _subscriptionProvider.SubscribeUser(user, planId, trialEnds, taxPercent);
var subscription = await _subscriptionDataService.SubscribeUserAsync
(user, planId, trialEnds, taxPercent, subscriptionId);
// Update tax percent on stripe
if (subscription.TaxPercent > 0)
{
await this.UpdateSubscriptionTax(user, subscription.StripeId, subscription.TaxPercent);
}
}
else
{
return(error);
}
return(null);
}
/// <summary>
/// Updates the credit card asynchronous.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="creditcard">The creditcard.</param>
/// <returns></returns>
public async Task UpdateAsync(SaasEcomUser user, CreditCard creditcard)
{
// Remove current card from stripe
var currentCard = await _cardDataService.FindAsync(user.Id, creditcard.Id, true);
var stripeCustomerId = user.StripeCustomerId;
_cardService.Delete(stripeCustomerId, currentCard.StripeId);
this.AddCardToStripe(creditcard, stripeCustomerId);
// Update card in the DB
creditcard.SaasEcomUserId = user.Id;
await _cardDataService.UpdateAsync(user.Id, creditcard);
}
/// <summary>
/// Updates the customer.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="card">The card.</param>
/// <returns></returns>
public object UpdateCustomer(SaasEcomUser user, CreditCard card)
{
var customer = new StripeCustomerUpdateOptions
{
Email = user.Email,
// Card Details
Card = new StripeCreditCardOptions
{
TokenId = card.StripeToken
}
};
return(_customerService.Update(user.StripeCustomerId, customer));
}
/// <summary>
/// Subscribe an existing user to a plan.
/// </summary>
/// <param name="user">Application User</param>
/// <param name="planId">Stripe plan Id</param>
/// <param name="creditCard">Credit card to pay this subscription.</param>
/// <param name="trialInDays">The trial in days.</param>
/// <param name="taxPercent">The tax percent.</param>
/// <returns></returns>
public async Task SubscribeUserAsync(SaasEcomUser user, string planId, CreditCard creditCard, int trialInDays = 0, decimal taxPercent = 0)
{
// Save subscription details
var subscriptionId = _subscriptionProvider.SubscribeUser
(user, planId, trialInDays: trialInDays, taxPercent: taxPercent); // Stripe
await this._subscriptionDataService.SubscribeUserAsync(user, planId, trialInDays, taxPercent, subscriptionId); // DB
// Save payment details
if (creditCard.Id == 0)
{
await _cardProvider.AddAsync(user, creditCard);
}
else
{
await _cardProvider.UpdateAsync(user, creditCard);
}
}
/// <summary>
/// Creates a new user in Stripe and database.
/// </summary>
/// <param name="user">Application User</param>
/// <param name="planId">Plan Id to subscribe the user to</param>
/// <param name="taxPercent">The tax percent.</param>
/// <returns>
/// Task
/// </returns>
public async Task SubscribeNewUserAsync(SaasEcomUser user, string planId, decimal taxPercent = 0)
{
// Subscribe the user to the plan
var subscription = await _subscriptionDataService.SubscribeUserAsync(user, planId, trialPeriodInDays : null, taxPercent : taxPercent);
// Create a new customer in Stripe and subscribe him to the plan
var stripeUser = (StripeCustomer)await _customerProvider.CreateCustomerAsync(user, planId);
// Add subscription Id to the user
user.StripeCustomerId = stripeUser.Id;
// Save subscription Id
subscription.StripeId = GetStripeSubscriptionId(stripeUser);
await _subscriptionDataService.UpdateSubscriptionAsync(subscription);
// Update tax percent on stripe
if (taxPercent > 0)
{
await this.UpdateSubscriptionTax(user, subscription.StripeId, taxPercent);
}
}
/// <summary>
/// Subscribes the user, with a billing cycle that goes from the 1st of the month asynchronous.
/// Creates the user in Stripe if doesn't exist already.
/// Saves de Subscription data in the database if the subscription suceeds.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="planId">The plan identifier.</param>
/// <param name="card">The card.</param>
/// <param name="taxPercent">The tax percent.</param>
/// <returns></returns>
public async Task SubscribeUserNaturalMonthAsync(SaasEcomUser user, string planId, CreditCard card, decimal taxPercent = 0)
{
if (string.IsNullOrEmpty(user.StripeCustomerId))
{
// Create a new customer in Stripe and save card
var stripeUser = (StripeCustomer)await _customerProvider.CreateCustomerAsync(user, cardToken : card.StripeToken);
user.StripeCustomerId = stripeUser.Id;
card.SaasEcomUserId = user.Id;
await _cardDataService.AddAsync(card);
}
else if (card != null && !string.IsNullOrEmpty(card.StripeToken))
{
// Update the default card for the user
var customer = (StripeCustomer)_customerProvider.UpdateCustomer(user, card);
card.SaasEcomUserId = user.Id;
card.StripeId = customer.DefaultSourceId;
await _cardDataService.AddOrUpdateDefaultCardAsync(user.Id, card);
}
var stripeSubscription = (StripeSubscription)_subscriptionProvider.SubscribeUserNaturalMonth(user, planId, GetStartNextMonth(), taxPercent);
await _subscriptionDataService.SubscribeUserAsync(user, planId, (int?)null, taxPercent, stripeSubscription.Id);
}
/// <summary>
/// Creates the customer asynchronous.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="planId">The plan identifier.</param>
/// <param name="trialEnd">The trial end.</param>
/// <param name="cardToken">The card token.</param>
/// <returns></returns>
public async Task <object> CreateCustomerAsync(SaasEcomUser user, string planId = null, DateTime?trialEnd = null, string cardToken = null)
{
var customer = new StripeCustomerCreateOptions
{
AccountBalance = 0,
Email = user.Email
};
if (!string.IsNullOrEmpty(cardToken))
{
customer.SourceToken = cardToken;
}
if (!string.IsNullOrEmpty(planId))
{
customer.PlanId = planId;
customer.TrialEnd = trialEnd;
}
var stripeUser = await Task.Run(() => _customerService.Create(customer));
return(stripeUser);
}
/// <summary>
/// Cancel subscription from Stripe
/// </summary>
/// <param name="subscriptionId">Stripe subscription Id</param>
/// <param name="user">Application user</param>
/// <param name="cancelAtPeriodEnd">Cancel immediately or when the paid period ends (default immediately)</param>
/// <param name="reasonToCancel">The reason to cancel.</param>
/// <returns>The Date when the subscription ends (it can be future if cancelAtPeriodEnd is true)</returns>
public async Task <DateTime?> EndSubscriptionAsync(int subscriptionId, SaasEcomUser user, bool cancelAtPeriodEnd = false, string reasonToCancel = null)
{
DateTime?subscriptionEnd = null;
try
{
var subscription = await _subscriptionDataService.UserActiveSubscriptionAsync(user.Id);
if (subscription != null && subscription.Id == subscriptionId)
{
subscriptionEnd = _subscriptionProvider.EndSubscription(user.StripeCustomerId, subscription.StripeId, cancelAtPeriodEnd);
await _subscriptionDataService.EndSubscriptionAsync(subscriptionId, subscriptionEnd.Value, reasonToCancel);
}
}
catch (Exception)
{
// TODO: Log
subscriptionEnd = null;
}
return(subscriptionEnd);
}
/// <summary>
/// Deletes the customer.
/// </summary>
/// <param name="user">The user.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public void DeleteCustomer(SaasEcomUser user)
{
_customerService.Delete(user.StripeCustomerId);
}
