Method switch_plan

backend/metering_billing/models.py:3179–3302

(
        self,
        new_version,
        transfer_usage=True,
        invoice_now=True,
        component_fixed_charges_initial_units=None,
    )

        return True

    def switch_plan(
        self,
        new_version,
        transfer_usage=True,
        invoice_now=True,
        component_fixed_charges_initial_units=None,
    ):
        from metering_billing.invoice import generate_invoice

        if component_fixed_charges_initial_units is None:
            component_fixed_charges_initial_units = []
        component_fixed_charges_initial_units = {
            d["metric"]: d["units"] for d in component_fixed_charges_initial_units
        }
        # when switching a plan, there's a few things we need to take into account:
        # 1. flat fees dont transfer. Just end them.
        # 2. what does it mean for usage to transfer? Does it just mean the billing records for the old plan are cancelled and new ones are created for the new plan with a start date the same as previously? In the case we used to charge for x but no longer do, then perhaps in that case we do charge? If we weren;t doing the whole reset frequency thing anymore it would be awesome because we could just switch which plan component it points at and have the already billed for be a part of that.
        now = now_utc()
        sr = SubscriptionRecord.objects.create(
            organization=self.organization,
            customer=self.customer,
            billing_plan=new_version,
            start_date=now + relativedelta(microseconds=1),
            end_date=self.end_date,
            auto_renew=self.auto_renew,
        )
        # current recurring_charge billing records must be canceled + billed
        for billing_record in self.billing_records.filter(
            recurring_charge__isnull=False, fully_billed=False
        ):
            # this is common enough that we made a method for it
            SubscriptionRecord._billing_record_cancel_protocol(
                billing_record, now, invoice_now=invoice_now
            )
        # and now we generate the new recurring_charge billing records
        for recurring_charge in new_version.recurring_charges.all():
            sr._create_recurring_charge_billing_records(recurring_charge)
        # same for component based billing records
        # so we're going to have to create a new billing record for each component, except if the metric coincides in the old plan and the new plan, then if transfer usage is true we have to do some wizardry to accomplish this
        # first a set of components we'll create from scratch... if we transfer usage from anywhere we'll remove it from this set
        pcs_to_create_charges_for = set(new_version.plan_components.all())
        # dict of metrics for convenience
        new_version_metrics_map = {
            x.billable_metric: x for x in pcs_to_create_charges_for
        }
        for billing_record in self.billing_records.filter(
            component__isnull=False, fully_billed=False
        ):
            component = billing_record.component
            # if not transferring usage, simple, just cancel the billing record same as above
            if not transfer_usage:
                SubscriptionRecord._billing_record_cancel_protocol(
                    billing_record, now, invoice_now=invoice_now
                )
            else:
                metric = component.billable_metric
                if metric in new_version_metrics_map:
                    # if the metric is in the new plan, we perform the surgery to switch the billing record to the new plan. Don't create from scratch.