public async Task UpdateSubscriptionShouldReturnNotModified()
{
using (var store = GetDocumentStore())
{
var updateOptions = new SubscriptionUpdateOptions
{
Query = "from Users",
Name = "Created"
};
store.Subscriptions.Create(updateOptions);
var subscriptions = await store.Subscriptions.GetSubscriptionsAsync(0, 5);
var state = subscriptions.First();
Assert.Equal(1, subscriptions.Count);
Assert.Equal("Created", state.SubscriptionName);
Assert.Equal("from Users", state.Query);
store.Subscriptions.Update(updateOptions);
var newSubscriptions = await store.Subscriptions.GetSubscriptionsAsync(0, 5);
var newState = newSubscriptions.First();
Assert.Equal(1, newSubscriptions.Count);
Assert.Equal(state.SubscriptionName, newState.SubscriptionName);
Assert.Equal(state.Query, newState.Query);
Assert.Equal(state.SubscriptionId, newState.SubscriptionId);
}
}
public void UpdateSubscription(StripeChargeRequest req)
{
var newPlan = GetById(req.TenantId, req.SubscriptionLevel);
var info = GetByBusinessId(req.BusinessId);
var items = new List <SubscriptionItemUpdateOption> {
new SubscriptionItemUpdateOption {
PlanId = newPlan.StripePlanId
}
};
var options = new SubscriptionUpdateOptions
{
Items = items,
Prorate = false
};
var service = new SubscriptionService();
Subscription subscription = service.Update(info.StripeSubscriptionId, options);
dataProvider.ExecuteNonQuery(
"Subscriptions_Update",
(parameters) =>
{
parameters.AddWithValue("@SubscriptionLevel", req.SubscriptionLevel);
parameters.AddWithValue("@StripeSubscriptionId", info.StripeSubscriptionId);
parameters.AddWithValue("@BusinessId", req.BusinessId);
}
);
}
public ActionResult Pause()
{
try
{
StripeConfiguration.ApiKey = key;
StripeConfiguration.MaxNetworkRetries = 2;
var options = new SubscriptionUpdateOptions
{
PauseCollection = new SubscriptionPauseCollectionOptions
{
Behavior = "void",
ResumesAt = DateTime.Today.AddDays(1)
},
};
var service = new SubscriptionService();
service.Update(subscriptionId, options);
return(View("OrderStatus"));
}
catch (StripeException e)
{
var x = new
{
status = "Failed",
message = e.Message
};
return(this.Json(x));
}
}
/// <summary>
/// Updates or downgrades current subscription
/// </summary>
/// <returns></returns>
public async Task <Subscription> UpdateSubscription(PaymentModel payment)
{
var customerSubscription = await GetCustomerSubscription(payment.CustomerId); // get current
var subscriptionService = new SubscriptionService();
var subscriptions = new List <SubscriptionItemOptions>()
{
new SubscriptionItemOptions()
{
Id = customerSubscription.Id,
Plan = payment.PlanId,
}
};
var options = new SubscriptionUpdateOptions
{
CancelAtPeriodEnd = false,
Items = subscriptions,
};
var subscription = await subscriptionService.UpdateAsync(customerSubscription.Id, options);
return(subscription);
}
private async Task <Subscription> VerifyCorrectTaxRateForCharge(Invoice invoice, Subscription subscription)
{
if (!string.IsNullOrWhiteSpace(invoice?.CustomerAddress?.Country) && !string.IsNullOrWhiteSpace(invoice?.CustomerAddress?.PostalCode))
{
var localBitwardenTaxRates = await _taxRateRepository.GetByLocationAsync(
new TaxRate()
{
Country = invoice.CustomerAddress.Country,
PostalCode = invoice.CustomerAddress.PostalCode
}
);
if (localBitwardenTaxRates.Any())
{
var stripeTaxRate = await new TaxRateService().GetAsync(localBitwardenTaxRates.First().Id);
if (stripeTaxRate != null && !subscription.DefaultTaxRates.Any(x => x == stripeTaxRate))
{
subscription.DefaultTaxRates = new List <Stripe.TaxRate> {
stripeTaxRate
};
var subscriptionOptions = new SubscriptionUpdateOptions()
{
DefaultTaxRates = new List <string>()
{
stripeTaxRate.Id
}
};
subscription = await new SubscriptionService().UpdateAsync(subscription.Id, subscriptionOptions);
}
}
}
return(subscription);
}
public async Task <bool> CancelSubcription(string customerId)
{
var subcription = await _context.Subcriptions.Where(sub => sub.StripeCustomerId == customerId && sub.IsDisable == false).FirstOrDefaultAsync();
if (subcription != null)
{
StripeConfiguration.ApiKey = this._configuration.GetSection("Stripe")["SecretKey"];
var options = new SubscriptionUpdateOptions
{
CancelAtPeriodEnd = true,
};
var service = new SubscriptionService();
var resultToken = await service.UpdateAsync(subcription.StripeSubCriptionID, options);
if (resultToken.CancelAtPeriodEnd)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
private Stripe.Subscription UpdateStripeSubscriptionPlan(StripeSubUpdatePlanRequest request)
{
StripeConfiguration.ApiKey = _appKeys.StripeApiKey;
var service = new SubscriptionService();
Stripe.Subscription subscription = service.Get(request.SubscriptionId);
var items = new List <SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Id = subscription.Items.Data[0].Id,
Price = request.PriceId,
}
};
var options = new SubscriptionUpdateOptions
{
Items = items,
};
options.AddExpand("latest_invoice.payment_intent");
subscription = service.Update(request.SubscriptionId, options);
return(subscription);
}
public async Task CancelCommunitySubscription(Community community, BillingRecord billing)
{
var plan = plans.GetPlan(billing.PlanId) !;
if (plan.Stripe is StripePlan stripePlan)
{
try
{
var update = new SubscriptionUpdateOptions()
{
CancelAtPeriodEnd = true
};
await Subscriptions.UpdateAsync(billing.Stripe !.SubscriptionId, update, RequestOptions);
}
catch (StripeException e)
{
logger.LogError(e, "Failed to update stripe subscription");
throw;
}
}
else
{
throw new ArgumentException("StripePaymentProcessor requires a StripePlan");
}
}
public string TogglePause(string togglePause)
{ //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
//sk_test_51Gzaa1HAh8lBnQxza9cOAzY7LbfgQ4FWX2sYqiuHsoVWJg4mNDppueQkAVd0XIPU4GhcrNBca8aemNgr24m4jDv200ooFw0Bhz
StripeConfiguration.ApiKey = "sk_test_51Gzaa1HAh8lBnQxza9cOAzY7LbfgQ4FWX2sYqiuHsoVWJg4mNDppueQkAVd0XIPU4GhcrNBca8aemNgr24m4jDv200ooFw0Bhz";
var msg = "";
if (togglePause == "pause")
{
var options = new SubscriptionUpdateOptions
{
PauseCollection = new SubscriptionPauseCollectionOptions
{
Behavior = "mark_uncollectible",
},
};
var service = new SubscriptionService();
service.Update("sub_HZ5QvvcLgLx8vW", options);
msg = "Subscription paused";
}
else if (togglePause == "resume")
{
var options = new SubscriptionUpdateOptions();
options.AddExtraParam("pause_collection", "");
var service = new SubscriptionService();
service.Update("sub_HZ5QvvcLgLx8vW", options);
msg = "Subscription resumed";
}
//ViewBag.message = msg;
return(msg);
}
// refer: https://stripe.com/docs/api/subscriptions/update
public async Task UpdateSubscriptionAsync(string subscriptionId, Action <SubscriptionUpdateOptions> action)
{
var options = new SubscriptionUpdateOptions();
action(options);
await _subscriptionService.UpdateAsync(subscriptionId, options);
}
public Subscription Update(string customerId, string subscriptionId, SubscriptionUpdateOptions updateOptions)
{
if (updateOptions == null)
{
updateOptions = new SubscriptionUpdateOptions();
}
return(_stripeSubscriptionService.Update(subscriptionId, updateOptions));
}
public SubscriptionServiceTest(
StripeMockFixture stripeMockFixture,
MockHttpClientFixture mockHttpClientFixture)
: base(stripeMockFixture, mockHttpClientFixture)
{
this.service = new SubscriptionService(this.StripeClient);
this.cancelOptions = new SubscriptionCancelOptions
{
InvoiceNow = true,
Prorate = true,
};
this.createOptions = new SubscriptionCreateOptions
{
Customer = "cus_123",
Items = new List <SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Price = "price_123",
Quantity = 2,
},
new SubscriptionItemOptions
{
PriceData = new SubscriptionItemPriceDataOptions
{
Currency = "usd",
Product = "prod_123",
Recurring = new SubscriptionItemPriceDataRecurringOptions
{
Interval = "day",
IntervalCount = 15,
},
UnitAmountDecimal = 0.01234567890m, // Ensure decimals work
},
Quantity = 3,
},
},
};
this.updateOptions = new SubscriptionUpdateOptions
{
Metadata = new Dictionary <string, string>
{
{ "key", "value" },
},
};
this.listOptions = new SubscriptionListOptions
{
Limit = 1,
};
}
public ActionResult continueSubscription()
{
StripeConfiguration.ApiKey = "sk_test_51GxEfiHhYK7K9XttqUpv12yjajZLs01TY95VhvzVfPEb5Ed8GaF3GFUV2iuhFZGkBgHoNib4iHBDlpALqWPplth6008EdMnnaw";
var options = new SubscriptionUpdateOptions();
options.AddExtraParam("pause_collection", "");
var service = new SubscriptionService();
service.Update("sub_HXNOGgEcJT2vvM", options);
return(Redirect("/Home/Billing"));
}
public async Task CancelSubscriptionAtPeriodEnd(Domain.Scheduling.Billing.Customer customer)
{
if (customer.Subscription == null)
{
throw new InvalidOperationException("No subscription to cancel.");
}
var opts = new SubscriptionUpdateOptions {
CancelAtPeriodEnd = true
};
await subscriptionService.UpdateAsync(customer.Subscription.BillingReference.BillingId, opts);
customer.Subscription.CancellingAtPeriodEnd = true;
}
public ActionResult pauseSubscription()
{
StripeConfiguration.ApiKey = "sk_test_51GxEfiHhYK7K9XttqUpv12yjajZLs01TY95VhvzVfPEb5Ed8GaF3GFUV2iuhFZGkBgHoNib4iHBDlpALqWPplth6008EdMnnaw";
var options = new SubscriptionUpdateOptions
{
PauseCollection = new SubscriptionPauseCollectionOptions
{
Behavior = "void",
},
};
var service = new SubscriptionService();
service.Update("sub_HXNOGgEcJT2vvM", options);
return(Redirect("/Home/Billing"));
}
public async Task CancelSubscriptionAtPeriodEnd(string customerEmail)
{
var spec = new InactiveInvitationByEmailSpec(customerEmail);
var invite = await _invitationRepository.GetBySpecAsync(spec);
if (invite is null)
{
throw new InvitationNotFoundException(customerEmail);
}
var subscriptionId = invite.PaymentHandlerSubscriptionId;
var subscriptionCancelOptions = new SubscriptionUpdateOptions
{
CancelAtPeriodEnd = true,
};
_subscriptionService.Update(subscriptionId, subscriptionCancelOptions);
}
public SubscriptionServiceTest(
StripeMockFixture stripeMockFixture,
MockHttpClientFixture mockHttpClientFixture)
: base(stripeMockFixture, mockHttpClientFixture)
{
this.service = new SubscriptionService(this.StripeClient);
this.cancelOptions = new SubscriptionCancelOptions
{
InvoiceNow = true,
Prorate = true,
};
this.createOptions = new SubscriptionCreateOptions
{
Customer = "cus_123",
Items = new List <SubscriptionItemOption>
{
new SubscriptionItemOption
{
Plan = "plan_123",
Quantity = 2,
},
new SubscriptionItemOption
{
Plan = "plan_124",
Quantity = 3,
},
},
};
this.updateOptions = new SubscriptionUpdateOptions
{
Metadata = new Dictionary <string, string>
{
{ "key", "value" },
},
};
this.listOptions = new SubscriptionListOptions
{
Limit = 1,
};
}
public async Task <PaymentGatewayResult <IPaymentSubscription> > UpdateSubscriptionAsync(string planId, ChargeType type,
string subscriptionId, string?coupon)
{
try
{
var subscription = await _subscriptionService.GetAsync(subscriptionId);
if (subscription == null)
{
throw new StripeException("Subscription Not Found")
{
HttpStatusCode = HttpStatusCode.NotFound
}
}
;
var opt = new SubscriptionUpdateOptions
{
CancelAtPeriodEnd = false,
Items = new List <SubscriptionItemUpdateOption> {
new SubscriptionItemUpdateOption {
Id = subscription.Items.Data.FirstOrDefault()?.Id,
PlanId = planId
},
},
CouponId = coupon,
Prorate = true,
ProrationDate = DateTime.UtcNow,
CollectionMethod = _chargeTypes[(int)type],
};
if (type == ChargeType.Manual)
{
opt.DaysUntilDue = _appSettings.Stripe.InvoiceDueDays;
}
subscription = await _subscriptionService.UpdateAsync(subscription.Id, opt);
return(PaymentGatewayResult <IPaymentSubscription> .Success(_mapper.Map <IPaymentSubscription>(subscription)));
}
catch (StripeException e)
{
return(PaymentGatewayResult <IPaymentSubscription> .Failed(e));
}
}
public async Task UndoCancellingSubscription(Domain.Scheduling.Billing.Customer customer)
{
if (customer.Subscription == null)
{
throw new InvalidOperationException("No subscription to cancel.");
}
if (!customer.Subscription.CancellingAtPeriodEnd)
{
throw new InvalidOperationException("Cannot undo what has not been done");
}
var opts = new SubscriptionUpdateOptions {
CancelAtPeriodEnd = false
};
await subscriptionService.UpdateAsync(customer.Subscription.BillingReference.BillingId, opts);
customer.Subscription.CancellingAtPeriodEnd = false;
}
public ActionResult<Subscription> UpdateSubscription([FromBody] UpdateSubscriptionRequest req)
{
var service = new SubscriptionService();
var subscription = service.Get(req.Subscription);
var options = new SubscriptionUpdateOptions
{
CancelAtPeriodEnd = false,
Items = new List<SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Id = subscription.Items.Data[0].Id,
Price = Environment.GetEnvironmentVariable(req.NewPrice),
}
}
};
var updatedSubscription = service.Update(req.Subscription, options);
return updatedSubscription;
}
public SubscriptionServiceTest()
{
this.service = new SubscriptionService();
this.cancelOptions = new SubscriptionCancelOptions
{
InvoiceNow = true,
Prorate = true,
};
this.createOptions = new SubscriptionCreateOptions
{
CustomerId = "cus_123",
Items = new List <SubscriptionItemOption>
{
new SubscriptionItemOption
{
PlanId = "plan_123",
Quantity = 2
},
new SubscriptionItemOption
{
PlanId = "plan_124",
Quantity = 3
},
},
};
this.updateOptions = new SubscriptionUpdateOptions
{
Metadata = new Dictionary <string, string>
{
{ "key", "value" },
},
};
this.listOptions = new SubscriptionListOptions
{
Limit = 1,
};
}
public Subscription Change(string subscriptionId, string subscriptionItemId, string overageSubscriptionItemId, string monthlyPlanId, string overagePlanId)
{
var subscriptionService = new Stripe.SubscriptionService();
var items = new List <SubscriptionItemOptions> {
new SubscriptionItemOptions {
Plan = monthlyPlanId,
},
new SubscriptionItemOptions {
Plan = overagePlanId,
}
};
var options = new SubscriptionUpdateOptions
{
CancelAtPeriodEnd = false,
Items = items,
};
return(subscriptionService.Update(subscriptionId, options));
}
public IActionResult Upgrade(string subKey, string plan)
{
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = _configuration["Stripe:SecretKey"];
var service = new SubscriptionService();
Subscription subscription = service.Get(subKey);
var planId = _configuration["Stripe:Daily5"];
if (plan == "Daily10")
{
planId = _configuration["Stripe:Daily10"];
}
var items = new List <SubscriptionItemOptions> {
new SubscriptionItemOptions {
Id = subscription.Items.Data[0].Id,
Price = planId,
},
};
var options = new SubscriptionUpdateOptions
{
CancelAtPeriodEnd = false,
ProrationBehavior = "create_prorations",
Items = items,
};
subscription = service.Update(subKey, options);
var subUpdate = _database.Subscriptions.Where(i => i.SubID == subKey).Single();
subUpdate.PlanID = planId;
_database.SaveChanges();
return(View("UpdateResult"));
}
public ActionResult Resume()
{
try
{
StripeConfiguration.ApiKey = key;
StripeConfiguration.MaxNetworkRetries = 2;
var options = new SubscriptionUpdateOptions();
options.AddExtraParam("pause_collection", "");
var service = new SubscriptionService();
service.Update(subscriptionId, options);
return(View("OrderStatus"));
}
catch (StripeException e)
{
var x = new
{
status = "Failed",
message = e.Message
};
return(this.Json(x));
}
}
public async Task <IActionResult> Webhook()
{
var json = await new StreamReader(HttpContext.Request.Body).ReadToEndAsync();
Event stripeEvent;
try
{
stripeEvent = EventUtility.ConstructEvent(
json,
Request.Headers["Stripe-Signature"],
this.options.Value.WebhookSecret
);
Console.WriteLine($"Webhook notification with type: {stripeEvent.Type} found for {stripeEvent.Id}");
}
catch (Exception e)
{
Console.WriteLine($"Something failed {e}");
return(BadRequest());
}
if (stripeEvent.Type == "invoice.payment_succeeded")
{
var invoice = stripeEvent.Data.Object as Invoice;
if (invoice.BillingReason == "subscription_create")
{
// The subscription automatically activates after successful payment
// Set the payment method used to pay the first invoice
// as the default payment method for that subscription
// Retrieve the payment intent used to pay the subscription
var service = new PaymentIntentService();
var paymentIntent = service.Get(invoice.PaymentIntentId);
// Set the default payment method
var options = new SubscriptionUpdateOptions
{
DefaultPaymentMethod = paymentIntent.PaymentMethodId,
};
var subscriptionService = new SubscriptionService();
subscriptionService.Update(invoice.SubscriptionId, options);
Console.WriteLine($"Default payment method set for subscription: {paymentIntent.PaymentMethodId}");
}
Console.WriteLine($"Payment succeeded for invoice: {stripeEvent.Id}");
}
if (stripeEvent.Type == "invoice.paid")
{
// Used to provision services after the trial has ended.
// The status of the invoice will show up as paid. Store the status in your
// database to reference when a user accesses your service to avoid hitting rate
// limits.
}
if (stripeEvent.Type == "invoice.payment_failed")
{
// If the payment fails or the customer does not have a valid payment method,
// an invoice.payment_failed event is sent, the subscription becomes past_due.
// Use this webhook to notify your user that their payment has
// failed and to retrieve new card details.
}
if (stripeEvent.Type == "invoice.finalized")
{
// If you want to manually send out invoices to your customers
// or store them locally to reference to avoid hitting Stripe rate limits.
}
if (stripeEvent.Type == "customer.subscription.deleted")
{
// handle subscription cancelled automatically based
// upon your subscription settings. Or if the user cancels it.
}
if (stripeEvent.Type == "customer.subscription.trial_will_end")
{
// Send notification to your user that the trial will end
}
return(Ok());
}
public async Task <ActionResult <ChangePlanResult> > ChangePlanAsync(string id, string planId, string stripeToken = null, string last4 = null, string couponId = null)
{
if (String.IsNullOrEmpty(id) || !CanAccessOrganization(id))
{
return(NotFound());
}
if (!_options.StripeOptions.EnableBilling)
{
return(Ok(ChangePlanResult.FailWithMessage("Plans cannot be changed while billing is disabled.")));
}
var organization = await GetModelAsync(id, false);
if (organization == null)
{
return(Ok(ChangePlanResult.FailWithMessage("Invalid OrganizationId.")));
}
var plan = _billingManager.GetBillingPlan(planId);
if (plan == null)
{
return(Ok(ChangePlanResult.FailWithMessage("Invalid PlanId.")));
}
if (String.Equals(organization.PlanId, plan.Id) && String.Equals(_plans.FreePlan.Id, plan.Id))
{
return(Ok(ChangePlanResult.SuccessWithMessage("Your plan was not changed as you were already on the free plan.")));
}
// Only see if they can downgrade a plan if the plans are different.
if (!String.Equals(organization.PlanId, plan.Id))
{
var result = await _billingManager.CanDownGradeAsync(organization, plan, CurrentUser);
if (!result.Success)
{
return(Ok(result));
}
}
var client = new StripeClient(_options.StripeOptions.StripeApiKey);
var customerService = new CustomerService(client);
var subscriptionService = new SubscriptionService(client);
try {
// If they are on a paid plan and then downgrade to a free plan then cancel their stripe subscription.
if (!String.Equals(organization.PlanId, _plans.FreePlan.Id) && String.Equals(plan.Id, _plans.FreePlan.Id))
{
if (!String.IsNullOrEmpty(organization.StripeCustomerId))
{
var subs = await subscriptionService.ListAsync(new SubscriptionListOptions { Customer = organization.StripeCustomerId });
foreach (var sub in subs.Where(s => !s.CanceledAt.HasValue))
{
await subscriptionService.CancelAsync(sub.Id, new SubscriptionCancelOptions());
}
}
organization.BillingStatus = BillingStatus.Trialing;
organization.RemoveSuspension();
}
else if (String.IsNullOrEmpty(organization.StripeCustomerId))
{
if (String.IsNullOrEmpty(stripeToken))
{
return(Ok(ChangePlanResult.FailWithMessage("Billing information was not set.")));
}
organization.SubscribeDate = SystemClock.UtcNow;
var createCustomer = new CustomerCreateOptions {
Source = stripeToken,
Plan = planId,
Description = organization.Name,
Email = CurrentUser.EmailAddress
};
if (!String.IsNullOrWhiteSpace(couponId))
{
createCustomer.Coupon = couponId;
}
var customer = await customerService.CreateAsync(createCustomer);
organization.BillingStatus = BillingStatus.Active;
organization.RemoveSuspension();
organization.StripeCustomerId = customer.Id;
if (customer.Sources.Data.Count > 0)
{
organization.CardLast4 = (customer.Sources.Data.First() as Card)?.Last4;
}
}
else
{
var update = new SubscriptionUpdateOptions {
Items = new List <SubscriptionItemOptions>()
};
var create = new SubscriptionCreateOptions {
Customer = organization.StripeCustomerId, Items = new List <SubscriptionItemOptions>()
};
bool cardUpdated = false;
var customerUpdateOptions = new CustomerUpdateOptions {
Description = organization.Name, Email = CurrentUser.EmailAddress
};
if (!String.IsNullOrEmpty(stripeToken))
{
customerUpdateOptions.Source = stripeToken;
cardUpdated = true;
}
await customerService.UpdateAsync(organization.StripeCustomerId, customerUpdateOptions);
var subscriptionList = await subscriptionService.ListAsync(new SubscriptionListOptions { Customer = organization.StripeCustomerId });
var subscription = subscriptionList.FirstOrDefault(s => !s.CanceledAt.HasValue);
if (subscription != null)
{
update.Items.Add(new SubscriptionItemOptions {
Id = subscription.Items.Data[0].Id, Plan = planId
});
await subscriptionService.UpdateAsync(subscription.Id, update);
}
else
{
create.Items.Add(new SubscriptionItemOptions {
Plan = planId
});
await subscriptionService.CreateAsync(create);
}
if (cardUpdated)
{
organization.CardLast4 = last4;
}
organization.BillingStatus = BillingStatus.Active;
organization.RemoveSuspension();
}
_billingManager.ApplyBillingPlan(organization, plan, CurrentUser);
await _repository.SaveAsync(organization, o => o.Cache());
await _messagePublisher.PublishAsync(new PlanChanged { OrganizationId = organization.Id });
} catch (Exception ex) {
using (_logger.BeginScope(new ExceptionlessState().Tag("Change Plan").Identity(CurrentUser.EmailAddress).Property("User", CurrentUser).SetHttpContext(HttpContext)))
_logger.LogCritical(ex, "An error occurred while trying to update your billing plan: {Message}", ex.Message);
return(Ok(ChangePlanResult.FailWithMessage(ex.Message)));
}
return(Ok(new ChangePlanResult {
Success = true
}));
}
public async Task <PaymentGatewayResult <IPaymentSubscription> > UpdateSubscriptionAsync(string id, SubscriptionUpdateOptions options)
{
try
{
var subscription = await _subscriptionService.GetAsync(id);
subscription = await _subscriptionService.UpdateAsync(subscription.Id, options);
return(PaymentGatewayResult <IPaymentSubscription> .Success(_mapper.Map <IPaymentSubscription>(subscription)));
}
catch (StripeException e)
{
return(PaymentGatewayResult <IPaymentSubscription> .Failed(e));
}
}
public UpdateSubscriptionCommand(SubscriptionUpdateOptions options)
{
_options = options;
}
public virtual async Task <Subscription> Update(string customerId, string subscriptionId, SubscriptionUpdateOptions updateOptions)
{
var url = string.Format(Urls.Subscriptions + "/{1}", customerId, subscriptionId);
url = this.ApplyAllParameters(updateOptions, url, false);
var response = await Requestor.Post(url);
return(Mapper <Subscription> .MapFromJson(response));
}
public ActionResult <UpdateSubscriptionResponse> UpdateSubscription([FromBody] UpdateSubscriptionRequest req)
{
if (!ModelState.IsValid)
{
return(this.FailWithMessage("invalid params"));
}
var newPrice = Environment.GetEnvironmentVariable(req.NewPrice);
if (newPrice is null || newPrice == "")
{
return(this.FailWithMessage($"No price with the new price ID ({req.NewPrice}) found in .env"));
}
var service = new SubscriptionService();
Subscription subscription;
try
{
subscription = service.Get(req.Subscription);
}
catch (StripeException e)
{
return(this.FailWithMessage($"Failed to retrieve subscription: {e}"));
}
var currentPrice = subscription.Items.Data[0].Price.Id;
List <SubscriptionItemOptions> items;
if (currentPrice == newPrice)
{
items = new List <SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Id = subscription.Items.Data[0].Id,
Quantity = req.Quantity,
},
};
}
else
{
items = new List <SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Id = subscription.Items.Data[0].Id,
Deleted = true,
},
new SubscriptionItemOptions
{
Price = newPrice,
Quantity = req.Quantity,
},
};
}
var options = new SubscriptionUpdateOptions
{
CancelAtPeriodEnd = false,
Items = items,
ProrationBehavior = "always_invoice",
};
var updatedSubscription = service.Update(req.Subscription, options);
return(new UpdateSubscriptionResponse
{
Subscription = updatedSubscription,
});
}
