billing: Support switching from monthly to annual plan.

corporate/lib/stripe.py

@@ -125,14 +125,21 @@ def next_invoice_date(plan: CustomerPlan) -> Optional[datetime]:
 def renewal_amount(plan: CustomerPlan, event_time: datetime) -> int:  # nocoverage: TODO
     if plan.fixed_price is not None:
         return plan.fixed_price
-    last_ledger_entry = make_end_of_cycle_updates_if_needed(plan, event_time)
+    new_plan, last_ledger_entry = make_end_of_cycle_updates_if_needed(plan, event_time)
     if last_ledger_entry is None:
         return 0
     if last_ledger_entry.licenses_at_next_renewal is None:
         return 0
+    if new_plan is not None:
+        plan = new_plan
     assert(plan.price_per_license is not None)  # for mypy
     return plan.price_per_license * last_ledger_entry.licenses_at_next_renewal
 
+def get_idempotency_key(ledger_entry: LicenseLedger) -> Optional[str]:
+    if settings.TEST_SUITE:
+        return None
+    return f'ledger_entry:{ledger_entry.id}'  # nocoverage
+
 class BillingError(Exception):
     # error messages
     CONTACT_SUPPORT = _("Something went wrong. Please contact {email}.").format(
@@ -237,14 +244,14 @@ def do_replace_payment_source(user: UserProfile, stripe_token: str,
 # event_time should roughly be timezone_now(). Not designed to handle
 # event_times in the past or future
 def make_end_of_cycle_updates_if_needed(plan: CustomerPlan,
-                                        event_time: datetime) -> Optional[LicenseLedger]:
+                                        event_time: datetime) -> Tuple[Optional[CustomerPlan], Optional[LicenseLedger]]:
     last_ledger_entry = LicenseLedger.objects.filter(plan=plan).order_by('-id').first()
     last_renewal = LicenseLedger.objects.filter(plan=plan, is_renewal=True) \
                                         .order_by('-id').first().event_time
     next_billing_cycle = start_of_next_billing_cycle(plan, last_renewal)
     if next_billing_cycle <= event_time:
         if plan.status == CustomerPlan.ACTIVE:
-            return LicenseLedger.objects.create(
+            return None, LicenseLedger.objects.create(
                 plan=plan, is_renewal=True, event_time=next_billing_cycle,
                 licenses=last_ledger_entry.licenses_at_next_renewal,
                 licenses_at_next_renewal=last_ledger_entry.licenses_at_next_renewal)
@@ -254,14 +261,52 @@ def make_end_of_cycle_updates_if_needed(plan: CustomerPlan,
             plan.billing_cycle_anchor = plan.next_invoice_date.replace(microsecond=0)
             plan.status = CustomerPlan.ACTIVE
             plan.save(update_fields=["invoiced_through", "billing_cycle_anchor", "status"])
-            return LicenseLedger.objects.create(
+            return None, LicenseLedger.objects.create(
                 plan=plan, is_renewal=True, event_time=next_billing_cycle,
                 licenses=last_ledger_entry.licenses_at_next_renewal,
                 licenses_at_next_renewal=last_ledger_entry.licenses_at_next_renewal)
+
+        if plan.status == CustomerPlan.SWITCH_TO_ANNUAL_AT_END_OF_CYCLE:
+            if plan.fixed_price is not None:  # nocoverage
+                raise NotImplementedError("Can't switch fixed priced monthly plan to annual.")
+
+            plan.status = CustomerPlan.ENDED
+            plan.save(update_fields=["status"])
+
+            discount = plan.customer.default_discount or plan.discount
+            _, _, _, price_per_license = compute_plan_parameters(
+                automanage_licenses=plan.automanage_licenses, billing_schedule=CustomerPlan.ANNUAL,
+                discount=plan.discount
+            )
+
+            new_plan = CustomerPlan.objects.create(
+                customer=plan.customer, billing_schedule=CustomerPlan.ANNUAL, automanage_licenses=plan.automanage_licenses,
+                charge_automatically=plan.charge_automatically, price_per_license=price_per_license,
+                discount=discount, billing_cycle_anchor=next_billing_cycle,
+                tier=plan.tier, status=CustomerPlan.ACTIVE, next_invoice_date=next_billing_cycle,
+                invoiced_through=None, invoicing_status=CustomerPlan.INITIAL_INVOICE_TO_BE_SENT,
+            )
+
+            new_plan_ledger_entry = LicenseLedger.objects.create(
+                plan=new_plan, is_renewal=True, event_time=next_billing_cycle,
+                licenses=last_ledger_entry.licenses_at_next_renewal,
+                licenses_at_next_renewal=last_ledger_entry.licenses_at_next_renewal
+            )
+
+            RealmAuditLog.objects.create(
+                realm=new_plan.customer.realm, event_time=event_time,
+                event_type=RealmAuditLog.CUSTOMER_SWITCHED_FROM_MONTHLY_TO_ANNUAL_PLAN,
+                extra_data=ujson.dumps({
+                    "monthly_plan_id": plan.id,
+                    "annual_plan_id": new_plan.id,
+                })
+            )
+            return new_plan, new_plan_ledger_entry
+
         if plan.status == CustomerPlan.DOWNGRADE_AT_END_OF_CYCLE:
             process_downgrade(plan)
-        return None
-    return last_ledger_entry
+        return None, None
+    return None, last_ledger_entry
 
 # Returns Customer instead of stripe_customer so that we don't make a Stripe
 # API call if there's nothing to update
@@ -410,11 +455,14 @@ def process_initial_upgrade(user: UserProfile, licenses: int, automanage_license
 
 def update_license_ledger_for_automanaged_plan(realm: Realm, plan: CustomerPlan,
                                                event_time: datetime) -> None:
-    last_ledger_entry = make_end_of_cycle_updates_if_needed(plan, event_time)
+    new_plan, last_ledger_entry = make_end_of_cycle_updates_if_needed(plan, event_time)
     if last_ledger_entry is None:
         return
+    if new_plan is not None:
+        plan = new_plan
     licenses_at_next_renewal = get_latest_seat_count(realm)
     licenses = max(licenses_at_next_renewal, last_ledger_entry.licenses)
+
     LicenseLedger.objects.create(
         plan=plan, event_time=event_time, licenses=licenses,
         licenses_at_next_renewal=licenses_at_next_renewal)
@@ -431,10 +479,17 @@ def invoice_plan(plan: CustomerPlan, event_time: datetime) -> None:
     if plan.invoicing_status == CustomerPlan.STARTED:
         raise NotImplementedError('Plan with invoicing_status==STARTED needs manual resolution.')
     make_end_of_cycle_updates_if_needed(plan, event_time)
-    assert(plan.invoiced_through is not None)
-    licenses_base = plan.invoiced_through.licenses
+
+    if plan.invoicing_status == CustomerPlan.INITIAL_INVOICE_TO_BE_SENT:
+        invoiced_through_id = -1
+        licenses_base = None
+    else:
+        assert(plan.invoiced_through is not None)
+        licenses_base = plan.invoiced_through.licenses
+        invoiced_through_id = plan.invoiced_through.id
+
     invoice_item_created = False
-    for ledger_entry in LicenseLedger.objects.filter(plan=plan, id__gt=plan.invoiced_through.id,
+    for ledger_entry in LicenseLedger.objects.filter(plan=plan, id__gt=invoiced_through_id,
                                                      event_time__lte=event_time).order_by('id'):
         price_args: Dict[str, int] = {}
         if ledger_entry.is_renewal:
@@ -445,7 +500,7 @@ def invoice_plan(plan: CustomerPlan, event_time: datetime) -> None:
                 price_args = {'unit_amount': plan.price_per_license,
                               'quantity': ledger_entry.licenses}
             description = "Zulip Standard - renewal"
-        elif ledger_entry.licenses != licenses_base:
+        elif licenses_base is not None and ledger_entry.licenses != licenses_base:
             assert(plan.price_per_license)
             last_renewal = LicenseLedger.objects.filter(
                 plan=plan, is_renewal=True, event_time__lte=ledger_entry.event_time) \
@@ -461,9 +516,6 @@ def invoice_plan(plan: CustomerPlan, event_time: datetime) -> None:
             plan.invoiced_through = ledger_entry
             plan.invoicing_status = CustomerPlan.STARTED
             plan.save(update_fields=['invoicing_status', 'invoiced_through'])
-            idempotency_key: Optional[str] = f'ledger_entry:{ledger_entry.id}'
-            if settings.TEST_SUITE:
-                idempotency_key = None
             stripe.InvoiceItem.create(
                 currency='usd',
                 customer=plan.customer.stripe_customer_id,
@@ -472,7 +524,7 @@ def invoice_plan(plan: CustomerPlan, event_time: datetime) -> None:
                 period = {'start': datetime_to_timestamp(ledger_entry.event_time),
                           'end': datetime_to_timestamp(
                               start_of_next_billing_cycle(plan, ledger_entry.event_time))},
-                idempotency_key=idempotency_key,
+                idempotency_key=get_idempotency_key(ledger_entry),
                 **price_args)
             invoice_item_created = True
         plan.invoiced_through = ledger_entry

corporate/models.py

@@ -44,6 +44,7 @@ class CustomerPlan(models.Model):
         'LicenseLedger', null=True, on_delete=CASCADE, related_name='+')
     DONE = 1
     STARTED = 2
+    INITIAL_INVOICE_TO_BE_SENT = 3
     invoicing_status: int = models.SmallIntegerField(default=DONE)
 
     STANDARD = 1
@@ -54,6 +55,7 @@ class CustomerPlan(models.Model):
     ACTIVE = 1
     DOWNGRADE_AT_END_OF_CYCLE = 2
     FREE_TRIAL = 3
+    SWITCH_TO_ANNUAL_AT_END_OF_CYCLE = 4
     # "Live" plans should have a value < LIVE_STATUS_THRESHOLD.
     # There should be at most one live plan per customer.
     LIVE_STATUS_THRESHOLD = 10

corporate/tests/stripe_fixtures/switch_from_monthly_plan_to_annual_plan_for_automatic_license_management--Charge.create.1.json

@@ -0,0 +1,116 @@
+{
+  "amount": 4800,
+  "amount_refunded": 0,
+  "application": null,
+  "application_fee": null,
+  "application_fee_amount": null,
+  "balance_transaction": "txn_NORMALIZED00000000000001",
+  "billing_details": {
+    "address": {
+      "city": "Pacific",
+      "country": "United States",
+      "line1": "Under the sea,",
+      "line2": null,
+      "postal_code": "33333",
+      "state": null
+    },
+    "email": null,
+    "name": "Ada Starr",
+    "phone": null
+  },
+  "calculated_statement_descriptor": "ZULIP STANDARD",
+  "captured": true,
+  "created": 1000000000,
+  "currency": "usd",
+  "customer": "cus_NORMALIZED0001",
+  "description": "Upgrade to Zulip Standard, $8.0 x 6",
+  "destination": null,
+  "dispute": null,
+  "disputed": false,
+  "failure_code": null,
+  "failure_message": null,
+  "fraud_details": {},
+  "id": "ch_NORMALIZED00000000000001",
+  "invoice": null,
+  "livemode": false,
+  "metadata": {},
+  "object": "charge",
+  "on_behalf_of": null,
+  "order": null,
+  "outcome": {
+    "network_status": "approved_by_network",
+    "reason": null,
+    "risk_level": "normal",
+    "risk_score": 00,
+    "seller_message": "Payment complete.",
+    "type": "authorized"
+  },
+  "paid": true,
+  "payment_intent": null,
+  "payment_method": "card_NORMALIZED00000000000001",
+  "payment_method_details": {
+    "card": {
+      "brand": "visa",
+      "checks": {
+        "address_line1_check": "pass",
+        "address_postal_code_check": "pass",
+        "cvc_check": "pass"
+      },
+      "country": "US",
+      "exp_month": 3,
+      "exp_year": 2033,
+      "fingerprint": "NORMALIZED000001",
+      "funding": "credit",
+      "installments": null,
+      "last4": "4242",
+      "network": "visa",
+      "three_d_secure": null,
+      "wallet": null
+    },
+    "type": "card"
+  },
+  "receipt_email": "[email protected]",
+  "receipt_number": null,
+  "receipt_url": "https://pay.stripe.com/receipts/acct_NORMALIZED000001/ch_NORMALIZED00000000000001/rcpt_NORMALIZED000000000000000000001",
+  "refunded": false,
+  "refunds": {
+    "data": [],
+    "has_more": false,
+    "object": "list",
+    "total_count": 0,
+    "url": "/v1/charges/ch_NORMALIZED00000000000001/refunds"
+  },
+  "review": null,
+  "shipping": null,
+  "source": {
+    "address_city": "Pacific",
+    "address_country": "United States",
+    "address_line1": "Under the sea,",
+    "address_line1_check": "pass",
+    "address_line2": null,
+    "address_state": null,
+    "address_zip": "33333",
+    "address_zip_check": "pass",
+    "brand": "Visa",
+    "country": "US",
+    "customer": "cus_NORMALIZED0001",
+    "cvc_check": "pass",
+    "dynamic_last4": null,
+    "exp_month": 3,
+    "exp_year": 2033,
+    "fingerprint": "NORMALIZED000001",
+    "funding": "credit",
+    "id": "card_NORMALIZED00000000000001",
+    "last4": "4242",
+    "metadata": {},
+    "name": "Ada Starr",
+    "object": "card",
+    "tokenization_method": null
+  },
+  "source_transfer": null,
+  "statement_descriptor": "Zulip Standard",
+  "statement_descriptor_suffix": null,
+  "status": "succeeded",
+  "transfer_data": null,
+  "transfer_group": null
+}

corporate/tests/stripe_fixtures/switch_from_monthly_plan_to_annual_plan_for_automatic_license_management--Customer.create.1.json

@@ -0,0 +1,80 @@
+{
+  "account_balance": 0,
+  "address": null,
+  "balance": 0,
+  "created": 1000000000,
+  "currency": null,
+  "default_source": "card_NORMALIZED00000000000001",
+  "delinquent": false,
+  "description": "zulip (Zulip Dev)",
+  "discount": null,
+  "email": "[email protected]",
+  "id": "cus_NORMALIZED0001",
+  "invoice_prefix": "NORMA01",
+  "invoice_settings": {
+    "custom_fields": null,
+    "default_payment_method": null,
+    "footer": null
+  },
+  "livemode": false,
+  "metadata": {
+    "realm_id": "1",
+    "realm_str": "zulip"
+  },
+  "name": null,
+  "next_invoice_sequence": 1,
+  "object": "customer",
+  "phone": null,
+  "preferred_locales": [],
+  "shipping": null,
+  "sources": {
+    "data": [
+      {
+        "address_city": "Pacific",
+        "address_country": "United States",
+        "address_line1": "Under the sea,",
+        "address_line1_check": "pass",
+        "address_line2": null,
+        "address_state": null,
+        "address_zip": "33333",
+        "address_zip_check": "pass",
+        "brand": "Visa",
+        "country": "US",
+        "customer": "cus_NORMALIZED0001",
+        "cvc_check": "pass",
+        "dynamic_last4": null,
+        "exp_month": 3,
+        "exp_year": 2033,
+        "fingerprint": "NORMALIZED000001",
+        "funding": "credit",
+        "id": "card_NORMALIZED00000000000001",
+        "last4": "4242",
+        "metadata": {},
+        "name": "Ada Starr",
+        "object": "card",
+        "tokenization_method": null
+      }
+    ],
+    "has_more": false,
+    "object": "list",
+    "total_count": 1,
+    "url": "/v1/customers/cus_NORMALIZED0001/sources"
+  },
+  "subscriptions": {
+    "data": [],
+    "has_more": false,
+    "object": "list",
+    "total_count": 0,
+    "url": "/v1/customers/cus_NORMALIZED0001/subscriptions"
+  },
+  "tax_exempt": "none",
+  "tax_ids": {
+    "data": [],
+    "has_more": false,
+    "object": "list",
+    "total_count": 0,
+    "url": "/v1/customers/cus_NORMALIZED0001/tax_ids"
+  },
+  "tax_info": null,
+  "tax_info_verification": null
+}