def _deactivate_subscription(subscription):
subscription.is_active = False
subscription.save()
next_subscription = subscription.next_subscription
activate_next_subscription = next_subscription and next_subscription.date_start == subscription.date_end
if activate_next_subscription:
new_plan_version = next_subscription.plan_version
next_subscription.is_active = True
next_subscription.save()
else:
next_subscription = assign_explicit_community_subscription(
subscription.subscriber.domain, subscription.date_end)
new_plan_version = next_subscription.plan_version
_, downgraded_privs, upgraded_privs = get_change_status(
subscription.plan_version, new_plan_version)
if subscription.account == next_subscription.account:
subscription.transfer_credits(subscription=next_subscription)
else:
subscription.transfer_credits()
subscription.subscriber.deactivate_subscription(
downgraded_privileges=downgraded_privs,
upgraded_privileges=upgraded_privs,
old_subscription=subscription,
new_subscription=next_subscription
if activate_next_subscription else None,
)
def _deactivate_subscription(subscription):
subscription.is_active = False
subscription.save()
next_subscription = subscription.next_subscription
activate_next_subscription = next_subscription and next_subscription.date_start == subscription.date_end
if activate_next_subscription:
new_plan_version = next_subscription.plan_version
next_subscription.is_active = True
next_subscription.save()
else:
next_subscription = assign_explicit_community_subscription(
subscription.subscriber.domain, subscription.date_end
)
new_plan_version = next_subscription.plan_version
_, downgraded_privs, upgraded_privs = get_change_status(subscription.plan_version, new_plan_version)
if subscription.account == next_subscription.account:
subscription.transfer_credits(subscription=next_subscription)
else:
subscription.transfer_credits()
subscription.subscriber.deactivate_subscription(
downgraded_privileges=downgraded_privs,
upgraded_privileges=upgraded_privs,
old_subscription=subscription,
new_subscription=next_subscription if activate_next_subscription else None,
)
def _terminate_subscriptions(domain_name):
today = date.today()
with transaction.atomic():
current_subscription = Subscription.get_active_subscription_by_domain(domain_name)
if current_subscription:
current_subscription.date_end = today
current_subscription.is_active = False
current_subscription.save()
current_subscription.transfer_credits()
_, downgraded_privs, upgraded_privs = get_change_status(current_subscription.plan_version, None)
current_subscription.subscriber.deactivate_subscription(
downgraded_privileges=downgraded_privs,
upgraded_privileges=upgraded_privs,
old_subscription=current_subscription,
new_subscription=None,
)
Subscription.visible_objects.filter(
Q(date_start__gt=today) | Q(date_start=today, is_active=False),
subscriber__domain=domain_name,
).update(is_hidden_to_ops=True)
def new_domain_subscription(cls, account, domain, plan_version, date_start=None, adjustment_method=None,
note=None, web_user=None, **kwargs):
subscriber = Subscriber.objects.get_or_create(domain=domain, organization=None)[0]
today = datetime.date.today()
future_subscriptions = Subscription.objects.filter(
models.Q(subscriber=subscriber, date_end__gt=today) | models.Q(subscriber=subscriber, date_end__exact=None)
)
if future_subscriptions.filter(is_active=True).count() > 0:
raise NewSubscriptionError(_("Project '%s' currently has an active subscription. "
"Please cancel the current subscription.") % domain)
try:
next_subscription = future_subscriptions.filter(date_start__gt=today).order_by('date_start')[0]
date_end = kwargs.get('date_end')
if date_end is None or date_end > next_subscription.date_start:
raise NewSubscriptionError(_("The end date for this subscription overlaps with the start date "
"of the next subscription on %s. Please cancel this subscription first.")
% next_subscription.date_start)
except (Subscription.DoesNotExist, IndexError):
pass
downgrades = get_change_status(None, plan_version)[1]
if downgrades:
subscriber.downgrade(plan_version, downgrades)
adjustment_method = adjustment_method or SubscriptionAdjustmentMethod.INTERNAL
subscription = Subscription(
account=account,
plan_version=plan_version,
subscriber=subscriber,
date_start=date_start or datetime.date.today(),
**kwargs
)
subscription.save()
SubscriptionAdjustment.record_adjustment(subscription, method=adjustment_method, note=note, web_user=web_user)
return subscription
def _deactivate_subscription(subscription):
subscription.is_active = False
subscription.save()
next_subscription = subscription.next_subscription
activate_next_subscription = next_subscription and next_subscription.date_start == subscription.date_end
if activate_next_subscription:
new_plan_version = next_subscription.plan_version
next_subscription.is_active = True
next_subscription.save()
else:
domain = subscription.subscriber.domain
if not subscription.account.is_customer_billing_account:
account = subscription.account
else:
account = BillingAccount.create_account_for_domain(
domain, created_by='default_community_after_customer_level')
next_subscription = assign_explicit_community_subscription(
domain,
subscription.date_end,
SubscriptionAdjustmentMethod.DEFAULT_COMMUNITY,
account=account)
new_plan_version = next_subscription.plan_version
_, downgraded_privs, upgraded_privs = get_change_status(
subscription.plan_version, new_plan_version)
if subscription.account == next_subscription.account:
subscription.transfer_credits(subscription=next_subscription)
else:
subscription.transfer_credits()
subscription.subscriber.deactivate_subscription(
downgraded_privileges=downgraded_privs,
upgraded_privileges=upgraded_privs,
old_subscription=subscription,
new_subscription=next_subscription
if activate_next_subscription else None,
)
def apply_upgrades_and_downgrades(self, downgraded_privileges=None,
upgraded_privileges=None,
new_plan_version=None,
verbose=False):
if self.organization is not None:
raise SubscriptionChangeError("Only domain upgrades and downgrades are possible.")
if new_plan_version is None:
new_plan_version = DefaultProductPlan.get_default_plan_by_domain(self.domain)
if downgraded_privileges is None or upgraded_privileges is None:
dp, up = get_change_status(None, new_plan_version)[1:]
downgraded_privileges = downgraded_privileges or dp
upgraded_privileges = upgraded_privileges or up
if downgraded_privileges:
downgrade_handler = DomainDowngradeActionHandler(
self.domain, new_plan_version, downgraded_privileges,
verbose=verbose,
)
if not downgrade_handler.get_response():
raise SubscriptionChangeError("The downgrade was not successful.")
if upgraded_privileges:
upgrade_handler = DomainUpgradeActionHandler(
self.domain, new_plan_version, upgraded_privileges,
verbose=verbose,
)
if not upgrade_handler.get_response():
raise SubscriptionChangeError("The upgrade was not successful.")
def _deactivate_subscription(subscription):
subscription.is_active = False
subscription.save()
next_subscription = subscription.next_subscription
activate_next_subscription = next_subscription and next_subscription.date_start == subscription.date_end
if activate_next_subscription:
new_plan_version = next_subscription.plan_version
next_subscription.is_active = True
next_subscription.save()
else:
domain = subscription.subscriber.domain
if not subscription.account.is_customer_billing_account:
account = subscription.account
else:
account = BillingAccount.create_account_for_domain(
domain, created_by='default_community_after_customer_level'
)
next_subscription = assign_explicit_community_subscription(
domain, subscription.date_end, SubscriptionAdjustmentMethod.DEFAULT_COMMUNITY, account=account
)
new_plan_version = next_subscription.plan_version
_, downgraded_privs, upgraded_privs = get_change_status(subscription.plan_version, new_plan_version)
if subscription.account == next_subscription.account:
subscription.transfer_credits(subscription=next_subscription)
else:
subscription.transfer_credits()
subscription.subscriber.deactivate_subscription(
downgraded_privileges=downgraded_privs,
upgraded_privileges=upgraded_privs,
old_subscription=subscription,
new_subscription=next_subscription if activate_next_subscription else None,
)
def _terminate_subscriptions(domain_name):
today = date.today()
with transaction.atomic():
current_subscription = Subscription.get_active_subscription_by_domain(domain_name)
if current_subscription:
current_subscription.date_end = today
current_subscription.is_active = False
current_subscription.save()
current_subscription.transfer_credits()
_, downgraded_privs, upgraded_privs = get_change_status(current_subscription.plan_version, None)
current_subscription.subscriber.deactivate_subscription(
downgraded_privileges=downgraded_privs,
upgraded_privileges=upgraded_privs,
old_subscription=current_subscription,
new_subscription=None,
)
Subscription.visible_objects.filter(
Q(date_start__gt=today) | Q(date_start=today, is_active=False),
subscriber__domain=domain_name,
).update(is_hidden_to_ops=True)
def _activate_subscription(subscription):
subscription.is_active = True
subscription.save()
upgraded_privs = get_change_status(None, subscription.plan_version).upgraded_privs
subscription.subscriber.activate_subscription(
upgraded_privileges=upgraded_privs,
subscription=subscription,
)
def _activate_subscription(subscription):
subscription.is_active = True
subscription.save()
upgraded_privs = get_change_status(None, subscription.plan_version).upgraded_privs
subscription.subscriber.activate_subscription(
upgraded_privileges=upgraded_privs,
subscription=subscription,
)
def activate_subscriptions(based_on_date=None):
"""
Activates all subscriptions starting today (or, for testing, based on the date specified)
"""
starting_date = based_on_date or datetime.date.today()
starting_subscriptions = Subscription.objects.filter(date_start=starting_date)
for subscription in starting_subscriptions:
if not has_subscription_already_ended(subscription) and not subscription.is_active:
subscription.is_active = True
subscription.save()
_, _, upgraded_privs = get_change_status(None, subscription.plan_version)
subscription.subscriber.apply_upgrades_and_downgrades(
upgraded_privileges=upgraded_privs,
)
def change_plan(self, new_plan_version, date_start=None, date_end=None, date_delay_invoicing=None,
salesforce_contract_id=None, do_not_invoice=False,
note=None, web_user=None, adjustment_method=None):
"""
Changing a plan terminates the current subscription and creates a new subscription where the old plan
left off.
"""
adjustment_method = adjustment_method or SubscriptionAdjustmentMethod.INTERNAL
adjustment_reason, downgrades, upgrades = get_change_status(self.plan_version, new_plan_version)
if adjustment_reason == SubscriptionAdjustmentReason.DOWNGRADE:
self.subscriber.downgrade(new_plan_version, downgrades)
today = datetime.date.today()
new_start_date = today if self.date_start <= today else (date_start or self.date_start)
new_is_active = self.is_active
new_salesforce_contract_id = salesforce_contract_id \
if salesforce_contract_id is not None else self.salesforce_contract_id
if self.date_start > today:
self.date_start = today
if self.date_end is None or self.date_end > today:
self.date_end = today
if self.date_delay_invoicing is not None and self.date_delay_invoicing > today:
self.date_delay_invoicing = today
self.is_active = False
self.save()
new_subscription =\
Subscription.new_domain_subscription(self.account,
self.subscriber.domain,
new_plan_version,
date_start=new_start_date,
date_end=date_end,
date_delay_invoicing=date_delay_invoicing,
salesforce_contract_id=new_salesforce_contract_id,
is_active=new_is_active,
do_not_invoice=do_not_invoice,
adjustment_method=adjustment_method,
note=note,
web_user=web_user
)
# record transfer from old subscription
SubscriptionAdjustment.record_adjustment(self, method=adjustment_method, note=note, web_user=web_user,
reason=adjustment_reason, related_subscription=new_subscription)
return new_subscription
def activate_subscriptions(based_on_date=None):
"""
Activates all subscriptions starting today (or, for testing, based on the date specified)
"""
starting_date = based_on_date or datetime.date.today()
starting_subscriptions = Subscription.objects.filter(date_start=starting_date)
for subscription in starting_subscriptions:
if not has_subscription_already_ended(subscription) and not subscription.is_active:
subscription.is_active = True
subscription.save()
_, _, upgraded_privs = get_change_status(None, subscription.plan_version)
subscription.subscriber.apply_upgrades_and_downgrades(
upgraded_privileges=upgraded_privs,
new_subscription=subscription,
)
def deactivate_subscriptions(based_on_date=None):
"""
Deactivates all subscriptions ending today (or, for testing, based on the date specified)
"""
ending_date = based_on_date or datetime.date.today()
ending_subscriptions = Subscription.objects.filter(date_end=ending_date)
for subscription in ending_subscriptions:
subscription.is_active = False
subscription.save()
if subscription.next_subscription and subscription.next_subscription.date_start == ending_date:
new_plan_version = subscription.next_subscription.plan_version
subscription.next_subscription.is_active = True
subscription.next_subscription.save()
else:
new_plan_version = None
_, downgraded_privs, upgraded_privs = get_change_status(subscription.plan_version, new_plan_version)
subscription.subscriber.apply_upgrades_and_downgrades(
downgraded_privileges=downgraded_privs,
upgraded_privileges=upgraded_privs,
)
def _deactivate_subscription(subscription, ending_date):
subscription.is_active = False
subscription.save()
next_subscription = subscription.next_subscription
activate_next_subscription = next_subscription and next_subscription.date_start == ending_date
if activate_next_subscription:
new_plan_version = next_subscription.plan_version
next_subscription.is_active = True
next_subscription.save()
else:
new_plan_version = None
_, downgraded_privs, upgraded_privs = get_change_status(subscription.plan_version, new_plan_version)
if next_subscription and subscription.account == next_subscription.account:
subscription.transfer_credits(subscription=next_subscription)
else:
subscription.transfer_credits()
subscription.subscriber.deactivate_subscription(
downgraded_privileges=downgraded_privs,
upgraded_privileges=upgraded_privs,
old_subscription=subscription,
new_subscription=next_subscription if activate_next_subscription else None,
)
def deactivate_subscriptions(based_on_date=None):
"""
Deactivates all subscriptions ending today (or, for testing, based on the date specified)
"""
ending_date = based_on_date or datetime.date.today()
ending_subscriptions = Subscription.objects.filter(date_end=ending_date)
for subscription in ending_subscriptions:
subscription.is_active = False
subscription.save()
next_subscription = subscription.next_subscription
if next_subscription and next_subscription.date_start == ending_date:
new_plan_version = next_subscription.plan_version
next_subscription.is_active = True
next_subscription.save()
else:
new_plan_version = None
_, downgraded_privs, upgraded_privs = get_change_status(subscription.plan_version, new_plan_version)
subscription.subscriber.apply_upgrades_and_downgrades(
downgraded_privileges=downgraded_privs,
upgraded_privileges=upgraded_privs,
old_subscription=subscription,
new_subscription=next_subscription,
)
