π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
package controller
import (
"database/sql"
"encoding/json"
"errors"
"fmt"
"net/http"
"strconv"
"time"
"github.com/ente/museum/pkg/controller/commonbilling"
"github.com/ente/museum/pkg/controller/discord"
"github.com/ente/museum/pkg/controller/offer"
"github.com/ente/museum/pkg/repo/storagebonus"
"github.com/ente/museum/ente"
emailCtrl "github.com/ente/museum/pkg/controller/email"
"github.com/ente/museum/pkg/repo"
"github.com/ente/museum/pkg/utils/billing"
"github.com/ente/museum/pkg/utils/email"
timeUtil "github.com/ente/museum/pkg/utils/time"
"github.com/ente/stacktrace"
log "github.com/sirupsen/logrus"
"github.com/spf13/viper"
"github.com/stripe/stripe-go/v72"
"github.com/stripe/stripe-go/v72/client"
"github.com/stripe/stripe-go/v72/webhook"
"golang.org/x/text/currency"
)
type StripeController struct {
StripeClients ente.StripeClientPerAccount
BillingPlansPerAccount ente.BillingPlansPerAccount
BillingRepo *repo.BillingRepository
FileRepo *repo.FileRepository
UserRepo *repo.UserRepository
StorageBonusRepo *storagebonus.Repository
DiscordController *discord.DiscordController
EmailNotificationCtrl *emailCtrl.EmailNotificationController
OfferController *offer.OfferController
CommonBillCtrl *commonbilling.Controller
}
const BufferPeriodOnPaymentFailureInDays = 7
func NewStripeController(plans ente.BillingPlansPerAccount, stripeClients ente.StripeClientPerAccount, billingRepo *repo.BillingRepository, fileRepo *repo.FileRepository, userRepo *repo.UserRepository, storageBonusRepo *storagebonus.Repository, discordController *discord.DiscordController, emailNotificationController *emailCtrl.EmailNotificationController, offerController *offer.OfferController, commonBillCtrl *commonbilling.Controller) *StripeController {
return &StripeController{
StripeClients: stripeClients,
BillingRepo: billingRepo,
FileRepo: fileRepo,
UserRepo: userRepo,
BillingPlansPerAccount: plans,
StorageBonusRepo: storageBonusRepo,
DiscordController: discordController,
EmailNotificationCtrl: emailNotificationController,
OfferController: offerController,
CommonBillCtrl: commonBillCtrl,
}
}
func (c *StripeController) GetCheckoutSession(productID string, userID int64, redirectRootURL string) (string, error) {
if productID == "" {
return "", stacktrace.Propagate(ente.ErrBadRequest, "")
}
subscription, err := c.BillingRepo.GetUserSubscription(userID)
if err != nil {
return "", stacktrace.Propagate(err, "")
}
hasActivePaidSubscription := billing.IsActivePaidPlan(subscription)
hasStripeSubscription := subscription.PaymentProvider == ente.Stripe
if hasActivePaidSubscription {
if hasStripeSubscription {
return "", stacktrace.Propagate(ente.ErrBadRequest, "")
} else if !subscription.Attributes.IsCancelled {
return "", stacktrace.Propagate(ente.ErrBadRequest, "")
}
}
if hasStripeSubscription {
client := c.StripeClients[subscription.Attributes.StripeAccountCountry]
stripeSubscription, err := client.Subscriptions.Get(subscription.OriginalTransactionID, nil)
if err != nil {
return "", stacktrace.Propagate(err, "")
}
if stripeSubscription.Status != stripe.SubscriptionStatusCanceled {
return "", stacktrace.Propagate(ente.ErrBadRequest, "")
}
}
stripeSuccessURL := redirectRootURL + viper.GetString("stripe.path.success")
stripeCancelURL := redirectRootURL + viper.GetString("stripe.path.cancel")
allowPromotionCodes := true
params := &stripe.CheckoutSessionParams{
ClientReferenceID: stripe.String(strconv.FormatInt(userID, 10)),
SuccessURL: stripe.String(stripeSuccessURL),
CancelURL: stripe.String(stripeCancelURL),
Mode: stripe.String(string(stripe.CheckoutSessionModeSubscription)),
LineItems: []*stripe.CheckoutSessionLineItemParams{
{
Price: stripe.String(productID),
Quantity: stripe.Int64(1),
},
},
AllowPromotionCodes: &allowPromotionCodes,
}
var stripeClient *client.API
if subscription.PaymentProvider == ente.Stripe {
stripeClient = c.StripeClients[subscription.Attributes.StripeAccountCountry]
params.Customer = stripe.String(subscription.Attributes.CustomerID)
} else {
stripeClient = c.StripeClients[ente.DefaultStripeAccountCountry]
user, err := c.UserRepo.Get(userID)
if err != nil {
return "", stacktrace.Propagate(err, "")
}
params.CustomerEmail = stripe.String(user.Email)
}
s, err := stripeClient.CheckoutSessions.New(params)
if err != nil {
return "", stacktrace.Propagate(err, "")
}
return s.ID, nil
}
func (c *StripeController) GetVerifiedSubscription(userID int64, sessionID string) (ente.Subscription, error) {
var stripeSubscription stripe.Subscription
var err error
if sessionID != "" {
log.Info("Received session ID: " + sessionID)
stripeSubscription, err = c.getStripeSubscriptionFromSession(userID, sessionID)
} else {
log.Info("Did not receive a session ID")
stripeSubscription, err = c.getUserStripeSubscription(userID)
}
if err != nil {
return ente.Subscription{}, stacktrace.Propagate(err, "")
}
log.Info("Received stripe subscription with ID: " + stripeSubscription.ID)
subscription, err := c.getEnteSubscriptionFromStripeSubscription(userID, stripeSubscription)
if err != nil {
return ente.Subscription{}, stacktrace.Propagate(err, "")
}
log.Info("Returning ente subscription with ID: " + strconv.FormatInt(subscription.ID, 10))
return subscription, nil
}
func (c *StripeController) HandleUSNotification(payload []byte, header string) error {
event, err := webhook.ConstructEvent(payload, header, viper.GetString("stripe.us.webhook-secret"))
if err != nil {
return stacktrace.Propagate(err, "")
}
return c.handleWebhookEvent(event, ente.StripeUS)
}
func (c *StripeController) HandleINNotification(payload []byte, header string) error {
event, err := webhook.ConstructEvent(payload, header, viper.GetString("stripe.in.webhook-secret"))
if err != nil {
return stacktrace.Propagate(err, "")
}
return c.handleWebhookEvent(event, ente.StripeIN)
}
func (c *StripeController) handleWebhookEvent(event stripe.Event, country ente.StripeAccountCountry) error {
handler := c.findHandlerForEvent(event)
if handler == nil {
log.Error("Received an unexpected webhook from stripe:", event.Type)
return nil
}
eventLog, err := handler(event, country)
if err != nil {
return stacktrace.Propagate(err, "")
}
if eventLog.UserID == 0 {
// Out-of-order events may have no user. Offer events are logged by
// StorageBonusRepo instead.
return nil
}
err = c.BillingRepo.LogStripePush(eventLog)
return stacktrace.Propagate(err, "")
}
func (c *StripeController) findHandlerForEvent(event stripe.Event) func(event stripe.Event, country ente.StripeAccountCountry) (ente.StripeEventLog, error) {
switch event.Type {
case "checkout.session.completed":
return c.handleCheckoutSessionCompleted
case "customer.subscription.updated":
return c.handleCustomerSubscriptionUpdated
case "invoice.paid":
return c.handleInvoicePaid
case "payment_intent.payment_failed":
return c.handlePaymentIntentFailed
default:
return nil
}
}
func (c *StripeController) handleCheckoutSessionCompleted(event stripe.Event, country ente.StripeAccountCountry) (ente.StripeEventLog, error) {
var session stripe.CheckoutSession
json.Unmarshal(event.Data.Raw, &session)
if session.ClientReferenceID != "" { // via payments.ente.com, where we inserted the userID
userID, _ := strconv.ParseInt(session.ClientReferenceID, 10, 64)
newSubscription, err := c.GetVerifiedSubscription(userID, session.ID)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
stripeSubscription, err := c.getStripeSubscriptionFromSession(userID, session.ID)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
currentSubscription, err := c.BillingRepo.GetUserSubscription(userID)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
if currentSubscription.ExpiryTime >= newSubscription.ExpiryTime &&
currentSubscription.ProductID != ente.FreePlanProductID {
if currentSubscription.PaymentProvider != newSubscription.PaymentProvider ||
currentSubscription.OriginalTransactionID != newSubscription.OriginalTransactionID ||
currentSubscription.ProductID != newSubscription.ProductID {
c.notifySkippedPaidStripeSubscriptionReplacement(userID, currentSubscription, newSubscription)
}
log.Warn("Webhook is reporting an outdated purchase that was already verified stripeSubscription:", stripeSubscription.ID)
return ente.StripeEventLog{UserID: userID, StripeSubscription: stripeSubscription, Event: event}, nil
}
isUpgradingFromFreePlan := currentSubscription.ProductID == ente.FreePlanProductID
if isUpgradingFromFreePlan {
newSubscription.UpgradedAt = timeUtil.Microseconds()
}
err = c.BillingRepo.ReplaceSubscription(
currentSubscription.ID,
newSubscription,
)
if isUpgradingFromFreePlan {
go func() {
cur := currency.MustParseISO(string(session.Currency))
amount := fmt.Sprintf("%v%v", currency.Symbol(cur), float64(session.AmountTotal)/float64(100))
c.DiscordController.NotifyNewSub(userID, "stripe", amount)
}()
go func() {
c.EmailNotificationCtrl.OnAccountUpgrade(userID)
}()
}
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
return ente.StripeEventLog{UserID: userID, StripeSubscription: stripeSubscription, Event: event}, nil
} else {
priceID, err := c.getPriceIDFromSession(session.ID)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
email := session.CustomerDetails.Email
err = c.OfferController.ApplyOffer(email, priceID)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
}
return ente.StripeEventLog{}, nil
}
func (c *StripeController) handleCustomerSubscriptionUpdated(event stripe.Event, country ente.StripeAccountCountry) (ente.StripeEventLog, error) {
var stripeSubscription stripe.Subscription
json.Unmarshal(event.Data.Raw, &stripeSubscription)
currentSubscription, err := c.BillingRepo.GetSubscriptionForTransaction(stripeSubscription.ID, ente.Stripe)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
log.Warn("Webhook is reporting an event for un-verified subscription stripeSubscriptionID:", stripeSubscription.ID)
return ente.StripeEventLog{}, nil
}
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
userID := currentSubscription.UserID
newSubscription, err := c.getEnteSubscriptionFromStripeSubscription(userID, stripeSubscription)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
// Other events update subscription state when the product is unchanged.
if currentSubscription.ProductID != newSubscription.ProductID {
c.BillingRepo.ReplaceSubscription(currentSubscription.ID, newSubscription)
}
fullStripeSub, err := c.getStripeSubscriptionWithPaymentMethod(currentSubscription)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
defaultPaymentMethodType := getSubscriptionPaymentMethodType(fullStripeSub)
if stripeSubscription.Status == stripe.SubscriptionStatusPastDue &&
!usesAllowIncompleteSubscriptionUpdate(defaultPaymentMethodType) {
// Subscription updates that do not use allow_incomplete surface failures
// via customer.subscription.updated. SEPA and UPI are handled within
// handlePaymentIntentFailed to avoid duplicate on-hold emails.
err = c.sendAccountOnHoldEmail(userID)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
}
return ente.StripeEventLog{UserID: userID, StripeSubscription: stripeSubscription, Event: event}, nil
}
func (c *StripeController) handleInvoicePaid(event stripe.Event, country ente.StripeAccountCountry) (ente.StripeEventLog, error) {
var invoice stripe.Invoice
json.Unmarshal(event.Data.Raw, &invoice)
stripeSubscriptionID := invoice.Subscription.ID
currentSubscription, err := c.BillingRepo.GetSubscriptionForTransaction(stripeSubscriptionID, ente.Stripe)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
if invoice.BillingReason != stripe.InvoiceBillingReasonSubscriptionCreate {
c.notifyIgnoredPaidStripeWebhook(event.Type, country, stripeSubscriptionID, invoice.Customer.ID)
}
log.Warn("Webhook is reporting an event for un-verified subscription stripeSubscriptionID:", stripeSubscriptionID)
return ente.StripeEventLog{}, nil
}
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
userID := currentSubscription.UserID
client := c.StripeClients[currentSubscription.Attributes.StripeAccountCountry]
stripeSubscription, err := client.Subscriptions.Get(stripeSubscriptionID, nil)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
newExpiryTime := stripeSubscription.CurrentPeriodEnd * 1000 * 1000
if currentSubscription.ExpiryTime == newExpiryTime {
log.Warn("Webhook is reporting an outdated purchase that was already verified stripeSubscriptionID:", stripeSubscription.ID)
return ente.StripeEventLog{UserID: userID, StripeSubscription: *stripeSubscription, Event: event}, nil
}
err = c.BillingRepo.UpdateSubscriptionExpiryTime(
currentSubscription.ID, newExpiryTime)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
return ente.StripeEventLog{UserID: userID, StripeSubscription: *stripeSubscription, Event: event}, nil
}
// SEPA and UPI failures are handled here because their updates use
// allow_incomplete.
func (c *StripeController) handlePaymentIntentFailed(event stripe.Event, country ente.StripeAccountCountry) (ente.StripeEventLog, error) {
var paymentIntent stripe.PaymentIntent
json.Unmarshal(event.Data.Raw, &paymentIntent)
paymentMethodType := getPaymentIntentErrorPaymentMethodType(paymentIntent)
if !usesAllowIncompleteSubscriptionUpdate(paymentMethodType) {
log.Info("Ignoring payment intent failed event for payment method handled synchronously")
return ente.StripeEventLog{}, nil
}
client := c.StripeClients[country]
invoiceID := paymentIntent.Invoice.ID
invoice, err := client.Invoices.Get(invoiceID, nil)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
stripeSubscriptionID := invoice.Subscription.ID
currentSubscription, err := c.BillingRepo.GetSubscriptionForTransaction(stripeSubscriptionID, ente.Stripe)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
log.Warn("Webhook is reporting an event for un-verified subscription stripeSubscriptionID:", stripeSubscriptionID)
}
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
userID := currentSubscription.UserID
stripeSubscription, err := client.Subscriptions.Get(stripeSubscriptionID, nil)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
if isPaidStripeInvoice(invoice) {
log.Info("Ignoring stale payment intent failed event for paid invoice:", invoiceID)
return ente.StripeEventLog{UserID: userID, StripeSubscription: *stripeSubscription, Event: event}, nil
}
productID := stripeSubscription.Items.Data[0].Price.ID
if currentSubscription.ProductID != productID {
log.Warn("Webhook is reporting un-verified subscription update", stripeSubscription.ID, "invoiceID:", invoiceID)
return ente.StripeEventLog{UserID: userID, StripeSubscription: *stripeSubscription, Event: event}, nil
}
newExpiryTime := time.Now().UnixMicro()
err = c.BillingRepo.UpdateSubscriptionExpiryTime(
currentSubscription.ID, newExpiryTime)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
err = c.BillingRepo.UpdateSubscriptionCancellationStatus(userID, true)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
err = c.sendAccountOnHoldEmail(userID)
if err != nil {
return ente.StripeEventLog{}, stacktrace.Propagate(err, "")
}
return ente.StripeEventLog{UserID: userID, StripeSubscription: *stripeSubscription, Event: event}, nil
}
func (c *StripeController) UpdateSubscription(stripeID string, userID int64) (ente.SubscriptionUpdateResponse, error) {
subscription, err := c.BillingRepo.GetUserSubscription(userID)
if err != nil {
return ente.SubscriptionUpdateResponse{}, stacktrace.Propagate(err, "")
}
newPlan, newStripeAccountCountry, err := c.getPlanAndAccount(stripeID)
if err != nil {
return ente.SubscriptionUpdateResponse{}, stacktrace.Propagate(err, "")
}
if subscription.PaymentProvider != ente.Stripe || subscription.ProductID == stripeID || subscription.Attributes.StripeAccountCountry != newStripeAccountCountry {
return ente.SubscriptionUpdateResponse{}, stacktrace.Propagate(ente.ErrBadRequest, "")
}
if newPlan.Storage < subscription.Storage {
canDowngrade, canDowngradeErr := c.CommonBillCtrl.CanDowngradeToGivenStorage(newPlan.Storage, userID)
if canDowngradeErr != nil {
return ente.SubscriptionUpdateResponse{}, stacktrace.Propagate(canDowngradeErr, "")
}
if !canDowngrade {
return ente.SubscriptionUpdateResponse{}, stacktrace.Propagate(ente.ErrCannotDowngrade, "")
}
log.Info("Usage is good")
}
stripeSubscription, err := c.getStripeSubscriptionWithPaymentMethod(subscription)
if err != nil {
return ente.SubscriptionUpdateResponse{}, stacktrace.Propagate(err, "")
}
defaultPaymentMethodType := getSubscriptionPaymentMethodType(stripeSubscription)
var paymentBehavior stripe.SubscriptionPaymentBehavior
if usesAllowIncompleteSubscriptionUpdate(defaultPaymentMethodType) {
paymentBehavior = stripe.SubscriptionPaymentBehaviorAllowIncomplete
} else {
paymentBehavior = stripe.SubscriptionPaymentBehaviorPendingIfIncomplete
}
params := stripe.SubscriptionParams{
ProrationBehavior: stripe.String(string(stripe.SubscriptionProrationBehaviorAlwaysInvoice)),
Items: []*stripe.SubscriptionItemsParams{
{
ID: stripe.String(stripeSubscription.Items.Data[0].ID),
Price: stripe.String(stripeID),
},
},
PaymentBehavior: stripe.String(string(paymentBehavior)),
}
params.AddExpand("latest_invoice.payment_intent")
client := c.StripeClients[subscription.Attributes.StripeAccountCountry]
newStripeSubscription, err := client.Subscriptions.Update(subscription.OriginalTransactionID, ¶ms)
if err != nil {
stripeError := err.(*stripe.Error)
switch stripeError.Type {
case stripe.ErrorTypeCard:
return ente.SubscriptionUpdateResponse{Status: "requires_payment_method"}, nil
default:
return ente.SubscriptionUpdateResponse{}, stacktrace.Propagate(err, "")
}
}
if paymentBehavior == stripe.SubscriptionPaymentBehaviorPendingIfIncomplete {
if newStripeSubscription.PendingUpdate != nil {
switch newStripeSubscription.LatestInvoice.PaymentIntent.Status {
case stripe.PaymentIntentStatusRequiresAction:
return ente.SubscriptionUpdateResponse{Status: "requires_action", ClientSecret: newStripeSubscription.LatestInvoice.PaymentIntent.ClientSecret}, nil
case stripe.PaymentIntentStatusRequiresPaymentMethod:
inv := newStripeSubscription.LatestInvoice
client.Invoices.VoidInvoice(inv.ID, nil)
return ente.SubscriptionUpdateResponse{Status: "requires_payment_method"}, nil
}
return ente.SubscriptionUpdateResponse{}, stacktrace.Propagate(ente.ErrBadRequest, "")
}
} else if newStripeSubscription.LatestInvoice != nil && newStripeSubscription.LatestInvoice.PaymentIntent != nil {
switch newStripeSubscription.LatestInvoice.PaymentIntent.Status {
case stripe.PaymentIntentStatusRequiresAction:
return ente.SubscriptionUpdateResponse{Status: "requires_action", ClientSecret: newStripeSubscription.LatestInvoice.PaymentIntent.ClientSecret}, nil
case stripe.PaymentIntentStatusRequiresPaymentMethod:
return ente.SubscriptionUpdateResponse{Status: "requires_payment_method"}, nil
case stripe.PaymentIntentStatusProcessing:
return ente.SubscriptionUpdateResponse{Status: "success"}, nil
case stripe.PaymentIntentStatusSucceeded:
return ente.SubscriptionUpdateResponse{Status: "success"}, nil
default:
return ente.SubscriptionUpdateResponse{}, stacktrace.Propagate(ente.ErrBadRequest, "")
}
}
return ente.SubscriptionUpdateResponse{Status: "success"}, nil
}
func (c *StripeController) UpdateSubscriptionCancellationStatus(userID int64, shouldCancel bool) (ente.Subscription, error) {
subscription, err := c.BillingRepo.GetUserSubscription(userID)
if err != nil {
return ente.Subscription{}, stacktrace.Propagate(err, "")
}
if subscription.PaymentProvider != ente.Stripe {
return ente.Subscription{}, stacktrace.Propagate(ente.ErrBadRequest, "")
}
if subscription.Attributes.IsCancelled == shouldCancel {
return subscription, nil
}
client := c.StripeClients[subscription.Attributes.StripeAccountCountry]
params := &stripe.SubscriptionParams{
CancelAtPeriodEnd: stripe.Bool(shouldCancel),
}
_, err = client.Subscriptions.Update(subscription.OriginalTransactionID, params)
if err != nil {
return ente.Subscription{}, c.handleStripeError(err, userID, "UpdateSubscriptionCancellationStatus")
}
if shouldCancel {
err = c.CommonBillCtrl.OnSubscriptionCancelled(userID)
} else {
err = c.BillingRepo.UpdateSubscriptionCancellationStatus(userID, false)
}
if err != nil {
return ente.Subscription{}, stacktrace.Propagate(err, "")
}
subscription.Attributes.IsCancelled = shouldCancel
return subscription, nil
}
func (c *StripeController) GetStripeCustomerPortal(userID int64, redirectRootURL string) (string, error) {
subscription, err := c.BillingRepo.GetUserSubscription(userID)
if err != nil {
return "", stacktrace.Propagate(err, "")
}
if subscription.PaymentProvider != ente.Stripe {
return "", stacktrace.Propagate(ente.ErrBadRequest, "")
}
client := c.StripeClients[subscription.Attributes.StripeAccountCountry]
params := &stripe.BillingPortalSessionParams{
Customer: stripe.String(subscription.Attributes.CustomerID),
ReturnURL: stripe.String(redirectRootURL),
}
ps, err := client.BillingPortalSessions.New(params)
if err != nil {
return "", c.handleStripeError(err, userID, "GetStripeCustomerPortal")
}
return ps.URL, nil
}
func (c *StripeController) getStripeSubscriptionWithPaymentMethod(subscription ente.Subscription) (stripe.Subscription, error) {
client := c.StripeClients[subscription.Attributes.StripeAccountCountry]
params := &stripe.SubscriptionParams{}
params.AddExpand("default_payment_method")
params.AddExpand("default_source")
params.AddExpand("customer.invoice_settings.default_payment_method")
params.AddExpand("customer.default_source")
stripeSubscription, err := client.Subscriptions.Get(subscription.OriginalTransactionID, params)
if err != nil {
return stripe.Subscription{}, stacktrace.Propagate(err, "")
}
return *stripeSubscription, nil
}
func (c *StripeController) sendAccountOnHoldEmail(userID int64) error {
user, err := c.UserRepo.Get(userID)
if err != nil {
return stacktrace.Propagate(err, "")
}
err = email.SendTemplatedEmail([]string{user.Email}, "ente", "[email protected]",
ente.AccountOnHoldEmailSubject, ente.OnHoldTemplate, map[string]interface{}{
"PaymentProvider": "Stripe",
}, nil)
return err
}
func (c *StripeController) notifyIgnoredPaidStripeWebhook(eventType string, country ente.StripeAccountCountry, stripeSubscriptionID string, customerID string) {
message := fmt.Sprintf(
"Paid Stripe webhook `%s` for unknown subscription `%s` on `%s` account (customer `%s`) was acknowledged with 2xx and no subscription row was updated.",
eventType,
stripeSubscriptionID,
country,
customerID,
)
c.DiscordController.NotifyThrottled(message, 30*time.Minute)
}
func (c *StripeController) notifySkippedPaidStripeSubscriptionReplacement(userID int64, currentSubscription ente.Subscription, newSubscription ente.Subscription) {
message := fmt.Sprintf(
"Paid Stripe checkout for user `%d` was acknowledged with 2xx but subscription replacement was skipped. Current: provider=`%s` txn=`%s` product=`%s` expiry=`%d`; incoming: provider=`%s` txn=`%s` product=`%s` expiry=`%d`.",
userID,
currentSubscription.PaymentProvider,
currentSubscription.OriginalTransactionID,
currentSubscription.ProductID,
currentSubscription.ExpiryTime,
newSubscription.PaymentProvider,
newSubscription.OriginalTransactionID,
newSubscription.ProductID,
newSubscription.ExpiryTime,
)
c.DiscordController.NotifyThrottled(message, 30*time.Minute)
}
func (c *StripeController) getStripeSubscriptionFromSession(userID int64, checkoutSessionID string) (stripe.Subscription, error) {
subscription, err := c.BillingRepo.GetUserSubscription(userID)
if err != nil {
return stripe.Subscription{}, stacktrace.Propagate(err, "")
}
var stripeClient *client.API
if subscription.PaymentProvider == ente.Stripe {
stripeClient = c.StripeClients[subscription.Attributes.StripeAccountCountry]
} else {
stripeClient = c.StripeClients[ente.DefaultStripeAccountCountry]
}
params := &stripe.CheckoutSessionParams{}
params.AddExpand("subscription")
checkoutSession, err := stripeClient.CheckoutSessions.Get(checkoutSessionID, params)
if err != nil {
return stripe.Subscription{}, stacktrace.Propagate(err, "")
}
if checkoutSession.ClientReferenceID != strconv.FormatInt(userID, 10) {
return stripe.Subscription{}, stacktrace.Propagate(ente.ErrPermissionDenied, "")
}
if (*checkoutSession.Subscription).Status != stripe.SubscriptionStatusActive {
return stripe.Subscription{}, stacktrace.Propagate(&stripe.InvalidRequestError{}, "")
}
return *checkoutSession.Subscription, nil
}
func (c *StripeController) getPriceIDFromSession(sessionID string) (string, error) {
stripeClient := c.StripeClients[ente.DefaultStripeAccountCountry]
params := &stripe.CheckoutSessionListLineItemsParams{}
params.AddExpand("data.price")
items := stripeClient.CheckoutSessions.ListLineItems(sessionID, params)
for items.Next() {
return items.LineItem().Price.ID, nil
}
return "", stacktrace.Propagate(ente.ErrNotFound, "")
}
func (c *StripeController) getUserStripeSubscription(userID int64) (stripe.Subscription, error) {
subscription, err := c.BillingRepo.GetUserSubscription(userID)
if err != nil {
return stripe.Subscription{}, stacktrace.Propagate(err, "")
}
if subscription.PaymentProvider != ente.Stripe {
return stripe.Subscription{}, stacktrace.Propagate(ente.ErrCannotSwitchPaymentProvider, "")
}
client := c.StripeClients[subscription.Attributes.StripeAccountCountry]
stripeSubscription, err := client.Subscriptions.Get(subscription.OriginalTransactionID, nil)
if err != nil {
return stripe.Subscription{}, stacktrace.Propagate(err, "")
}
return *stripeSubscription, nil
}
func (c *StripeController) getPlanAndAccount(stripeID string) (ente.BillingPlan, ente.StripeAccountCountry, error) {
for stripeAccountCountry, billingPlansCountryWise := range c.BillingPlansPerAccount {
for _, plans := range billingPlansCountryWise {
for _, plan := range plans {
if plan.StripeID == stripeID {
return plan, stripeAccountCountry, nil
}
}
}
}
return ente.BillingPlan{}, "", stacktrace.Propagate(ente.ErrNotFound, "")
}
func (c *StripeController) getEnteSubscriptionFromStripeSubscription(userID int64, stripeSubscription stripe.Subscription) (ente.Subscription, error) {
productID := stripeSubscription.Items.Data[0].Price.ID
plan, stripeAccountCountry, err := c.getPlanAndAccount(productID)
if err != nil {
return ente.Subscription{}, stacktrace.Propagate(err, "")
}
s := ente.Subscription{
UserID: userID,
PaymentProvider: ente.Stripe,
ProductID: productID,
Storage: plan.Storage,
Attributes: ente.SubscriptionAttributes{CustomerID: stripeSubscription.Customer.ID, IsCancelled: false, StripeAccountCountry: stripeAccountCountry},
OriginalTransactionID: stripeSubscription.ID,
ExpiryTime: stripeSubscription.CurrentPeriodEnd * 1000 * 1000,
}
return s, nil
}
func (c *StripeController) UpdateBillingEmail(subscription ente.Subscription, newEmail string) error {
params := &stripe.CustomerParams{Email: &newEmail}
client := c.StripeClients[subscription.Attributes.StripeAccountCountry]
_, err := client.Customers.Update(
subscription.Attributes.CustomerID,
params,
)
if err != nil {
return stacktrace.Propagate(err, "failed to update stripe customer emailID")
}
return nil
}
func (c *StripeController) CancelSubAndDeleteCustomer(subscription ente.Subscription, logger *log.Entry) error {
client := c.StripeClients[subscription.Attributes.StripeAccountCountry]
if !subscription.Attributes.IsCancelled {
prorateRefund := true
logger.Info("cancelling sub with prorated refund")
_, err := client.Subscriptions.Update(subscription.OriginalTransactionID, nil)
if err != nil {
stripeError := err.(*stripe.Error)
errorMsg := fmt.Sprintf("subscription updation failed during account deletion: %s, %s", stripeError.Msg, stripeError.Code)
log.Error(errorMsg)
c.DiscordController.Notify(errorMsg)
if stripeError.HTTPStatusCode == http.StatusNotFound {
log.Error("Ignoring error since an active subscription could not be found")
return nil
} else if stripeError.HTTPStatusCode == http.StatusBadRequest {
log.Error("Bad request while trying to delete account")
return nil
}
return stacktrace.Propagate(err, "")
}
_, err = client.Subscriptions.Cancel(subscription.OriginalTransactionID, &stripe.SubscriptionCancelParams{
Prorate: &prorateRefund,
})
if err != nil {
stripeError := err.(*stripe.Error)
logger.Error(fmt.Sprintf("subscription cancel failed msg= %s for userID=%d"+stripeError.Msg, subscription.UserID))
// ignore if subscription doesn't exist, already deleted
if stripeError.HTTPStatusCode != 404 {
return stacktrace.Propagate(err, "")
}
}
err = c.CommonBillCtrl.OnSubscriptionCancelled(subscription.UserID)
if err != nil {
return stacktrace.Propagate(err, "")
}
}
logger.Info("deleting customer from stripe")
_, err := client.Customers.Del(
subscription.Attributes.CustomerID,
&stripe.CustomerParams{},
)
if err != nil {
stripeError := err.(*stripe.Error)
switch stripeError.Type {
case stripe.ErrorTypeInvalidRequest:
if stripe.ErrorCodeResourceMissing == stripeError.Code {
return nil
}
return stacktrace.Propagate(err, "failed to delete customer %s", subscription.Attributes.CustomerID)
default:
return stacktrace.Propagate(err, "failed to delete customer %s", subscription.Attributes.CustomerID)
}
}
return nil
}
func getSubscriptionPaymentMethodType(stripeSubscription stripe.Subscription) stripe.PaymentMethodType {
if stripeSubscription.DefaultPaymentMethod == nil {
if stripeSubscription.DefaultSource != nil &&
stripeSubscription.DefaultSource.Type == stripe.PaymentSourceTypeCard {
return stripe.PaymentMethodTypeCard
}
if stripeSubscription.Customer != nil {
if stripeSubscription.Customer.InvoiceSettings != nil &&
stripeSubscription.Customer.InvoiceSettings.DefaultPaymentMethod != nil {
return stripeSubscription.Customer.InvoiceSettings.DefaultPaymentMethod.Type
}
if stripeSubscription.Customer.DefaultSource != nil &&
stripeSubscription.Customer.DefaultSource.Type == stripe.PaymentSourceTypeCard {
return stripe.PaymentMethodTypeCard
}
}
log.Info("No default payment method found on subscription or customer")
return ""
}
return stripeSubscription.DefaultPaymentMethod.Type
}
func usesAllowIncompleteSubscriptionUpdate(paymentMethodType stripe.PaymentMethodType) bool {
return paymentMethodType == stripe.PaymentMethodTypeSepaDebit || paymentMethodType == stripe.PaymentMethodType("upi")
}
func isPaidStripeInvoice(invoice *stripe.Invoice) bool {
return invoice.Paid || invoice.Status == stripe.InvoiceStatusPaid
}
func getPaymentIntentErrorPaymentMethodType(paymentIntent stripe.PaymentIntent) stripe.PaymentMethodType {
if paymentIntent.LastPaymentError == nil {
return ""
}
if paymentIntent.LastPaymentError.PaymentMethod != nil {
return paymentIntent.LastPaymentError.PaymentMethod.Type
}
if paymentIntent.LastPaymentError.Source != nil &&
paymentIntent.LastPaymentError.Source.Type == stripe.PaymentSourceTypeCard {
return stripe.PaymentMethodTypeCard
}
return paymentIntent.LastPaymentError.PaymentMethodType
}
func (c *StripeController) handleStripeError(err error, userID int64, context string) error {
if err == nil {
return nil
}
stripeError, ok := err.(*stripe.Error)
if !ok {
return stacktrace.Propagate(err, "")
}
if stripeError.Type == stripe.ErrorTypeInvalidRequest {
alertMsg := fmt.Sprintf(
"β οΈ Stripe Invalid Request Error\n"+
"**Context:** %s\n"+
"**User ID:** %d\n"+
"**Error Code:** %s\n"+
"**Message:** %s\n"+
"**Status:** %d\n"+
"**Request ID:** %s",
context,
userID,
stripeError.Code,
stripeError.Msg,
stripeError.HTTPStatusCode,
stripeError.RequestID,
)
c.DiscordController.Notify(alertMsg)
var userMsg string
switch stripeError.Code {
case stripe.ErrorCodeResourceMissing:
userMsg = "The requested resource no longer exists. Please create a new subscription or contact support."
default:
if stripeError.Msg != "" {
userMsg = fmt.Sprintf("Unable to process request: %s", stripeError.Msg)
} else {
userMsg = "Unable to process your request. Please contact support if the issue persists."
}
}
return stacktrace.Propagate(ente.NewBadRequestWithMessage(userMsg), "")
}
return stacktrace.Propagate(err, "")
}