def test_new_susbscription_in_future(self): """ Test covers issue that came up with commcare-hq/PR#3725. """ today = datetime.date.today() in_30_days = today + datetime.timedelta(days=30) week_after_30 = in_30_days + datetime.timedelta(days=7) next_year = week_after_30 + datetime.timedelta(days=400) # mimic domain signing up for trial trial_subscription = Subscription.new_domain_subscription( self.account, self.domain.name, self.advanced_plan, date_end=in_30_days, adjustment_method=SubscriptionAdjustmentMethod.TRIAL, is_trial=True, ) trial_subscription.is_active = True trial_subscription.save() subscription = Subscription.new_domain_subscription( self.account2, self.domain.name, self.standard_plan, web_user=self.admin_user_name, date_start=week_after_30, date_end=next_year, ) final_sub = Subscription.visible_objects.get(pk=subscription.id) self.assertEqual(final_sub.date_start, week_after_30) self.assertEqual(final_sub.date_end, next_year)
def test_resubscription(self): subscription = Subscription.new_domain_subscription( self.account, self.domain.name, self.advanced_plan, web_user=self.admin_user.username ) self._change_std_roles() subscription.cancel_subscription(web_user=self.admin_user.username) custom_role = UserRole.get(self.custom_role.get_id) self.assertTrue(custom_role.is_archived) subscription = Subscription.new_domain_subscription( self.account, self.domain.name, self.advanced_plan, web_user=self.admin_user.username ) custom_role = UserRole.get(self.custom_role.get_id) self.assertFalse(custom_role.is_archived) # disable this part of the test until we improve the UX for notifying # downgraded users of their privilege changes # custom_web_user = WebUser.get(self.web_users[0].get_id) # custom_commcare_user = CommCareUser.get(self.commcare_users[0].get_id) # self.assertEqual( # custom_web_user.get_domain_membership(self.domain.name).role_id, # self.read_only_role.get_id # ) # self.assertIsNone( # custom_commcare_user.get_domain_membership(self.domain.name).role_id # ) self.assertInitialRoles() self.assertStdUsers() subscription.cancel_subscription(web_user=self.admin_user.username)
def generate_domain_subscription_from_date(date_start, billing_account, domain, min_num_months=None, is_immediately_active=False, delay_invoicing_until=None, save=True): # make sure the first month is never a full month (for testing) date_start = date_start.replace(day=max(2, date_start.day)) subscription_length = random.randint(min_num_months or 3, 25) date_end_year, date_end_month = add_months(date_start.year, date_start.month, subscription_length) date_end_last_day = calendar.monthrange(date_end_year, date_end_month)[1] # make sure that the last month is never a full month (for testing) date_end = datetime.date(date_end_year, date_end_month, min(date_end_last_day - 1, date_start.day + 1)) subscriber, _ = Subscriber.objects.get_or_create(domain=domain, organization=None) subscription = Subscription( account=billing_account, plan_version=arbitrary_subscribable_plan(), subscriber=subscriber, salesforce_contract_id=data_gen.arbitrary_unique_name("SFC")[:80], date_start=date_start, date_end=date_end, is_active=is_immediately_active, date_delay_invoicing=delay_invoicing_until, ) if save: subscription.save() return subscription, subscription_length
def test_preexisting_past_subscription(self): past_subscription_end_date = self.from_date - timedelta(days=10) past_subscription_start_date = past_subscription_end_date - timedelta(days=5) plan_version = self._random_plan_version Subscription.new_domain_subscription( self._preexisting_subscription_account, self.domain.name, plan_version, date_start=past_subscription_start_date, date_end=past_subscription_end_date, ) self._assign_community_subscriptions() self.assertEqual(Subscription.objects.count(), 2) self.assertFalse(Subscription.objects.exclude(subscriber__domain=self.domain.name).exists()) self.assertIsNotNone(Subscription.objects.get( date_start=self.from_date, date_end=None, plan_version=self._most_recently_created_community_plan_version, skip_invoicing_if_no_feature_charges=True, )) self.assertIsNotNone(Subscription.objects.get( date_start=past_subscription_start_date, date_end=past_subscription_end_date, plan_version=plan_version, ))
def ensure_full_coverage(self, subscriptions): plan_version = DefaultProductPlan.get_default_plan_by_domain( self.domain, edition=SoftwarePlanEdition.COMMUNITY ).plan.get_version() if not plan_version.feature_charges_exist_for_domain(self.domain): return community_ranges = self.get_community_ranges(subscriptions) if not community_ranges: return do_not_invoice = any([s.do_not_invoice for s in subscriptions]) account = BillingAccount.get_or_create_account_by_domain( self.domain.name, created_by=self.__class__.__name__, created_by_invoicing=True)[0] if account.date_confirmed_extra_charges is None: if self.domain.is_active: subject = "[%s] Invoice Generation Issue" % self.domain.name email_content = render_to_string( 'accounting/invoice_error_email.html', { 'project': self.domain.name, 'error_msg': "This project is incurring charges on their " "Community subscription, but they haven't " "agreed to the charges yet. Someone should " "follow up with this project to see if everything " "is configured correctly or if communication " "needs to happen between Dimagi and the project's" "admins. For now, the invoices generated are " "marked as Do Not Invoice.", } ) send_HTML_email( subject, settings.BILLING_EMAIL, email_content, email_from="Dimagi Billing Bot <%s>" % settings.DEFAULT_FROM_EMAIL ) do_not_invoice = True if not BillingContactInfo.objects.filter(account=account).exists(): # No contact information exists for this account. # This shouldn't happen, but if it does, we can't continue # with the invoice generation. raise BillingContactInfoError( "Project %s has incurred charges, but does not have their " "Billing Contact Info filled out. Someone should follow up " "on this." % self.domain.name ) # First check to make sure none of the existing subscriptions is set # to do not invoice. Let's be on the safe side and not send a # community invoice out, if that's the case. for c in community_ranges: # create a new community subscription for each # date range that the domain did not have a subscription community_subscription = Subscription( account=account, plan_version=plan_version, subscriber=self.subscriber, date_start=c[0], date_end=c[1], do_not_invoice=do_not_invoice, ) community_subscription.save() subscriptions.append(community_subscription)
def test_exceeding_max_domains_prevents_new_domains(self): self.advanced_plan.plan.max_domains = 1 Subscription.new_domain_subscription( self.account, self.domain.name, self.advanced_plan ) self.assertRaises(NewSubscriptionError, lambda: Subscription.new_domain_subscription( self.account, self.domain2.name, self.advanced_plan ))
def test_change_plan_blocks_on_max_domains(self): Subscription.new_domain_subscription( self.account, self.domain.name, self.advanced_plan ) sub2 = Subscription.new_domain_subscription( self.account, self.domain2.name, self.community_plan ) self.assertRaises(SubscriptionAdjustmentError, lambda: sub2.change_plan(self.advanced_plan))
def test_next_subscription_filter_no_end_date(self): next_subscription = Subscription( account=self.subscription.account, plan_version=self.subscription.plan_version, subscriber=self.subscription.subscriber, date_start=self.subscription.date_end, date_end=None, ) next_subscription.save() self.assertEqual(next_subscription, self.subscription.next_subscription)
def test_full_coverage(self): some_plan = generator.subscribable_plan_version() Subscription.new_domain_subscription( self.account, self.domain.name, some_plan, date_start=self.invoice_start, date_end=self.invoice_end + datetime.timedelta(days=1), ) subscriptions = self.invoice_factory._get_subscriptions() community_ranges = self.invoice_factory._get_community_ranges(subscriptions) self.assertEqual(len(community_ranges), 0)
def test_transfers(self): advanced_plan = DefaultProductPlan.get_default_plan_version( edition=SoftwarePlanEdition.ADVANCED ) standard_plan = DefaultProductPlan.get_default_plan_version( edition=SoftwarePlanEdition.STANDARD ) first_sub = Subscription.new_domain_subscription( self.account, self.domain.name, advanced_plan, date_start=datetime.date.today() - relativedelta(days=1), ) product_credit = CreditLine.add_credit( self.product_credit_amt, subscription=first_sub, is_product=True, ) feature_credit = CreditLine.add_credit( self.feature_credit_amt, subscription=first_sub, feature_type=FeatureType.USER, ) subscription_credit = CreditLine.add_credit( self.subscription_credit_amt, subscription=first_sub, ) original_credits = [ product_credit, feature_credit, subscription_credit, ] second_sub = first_sub.change_plan(standard_plan) second_credits = self._ensure_transfer(original_credits) for credit_line in second_credits: self.assertEqual(credit_line.subscription.pk, second_sub.pk) second_sub.date_end = datetime.date.today() + datetime.timedelta(days=5) second_sub.save() third_sub = second_sub.renew_subscription() deactivate_subscriptions(second_sub.date_end) third_sub = Subscription.visible_objects.get(id=third_sub.id) third_credits = self._ensure_transfer(second_credits) for credit_line in third_credits: self.assertEqual(credit_line.subscription.pk, third_sub.pk) third_sub.date_end = third_sub.date_start + relativedelta(days=1) third_sub.save() Subscription.new_domain_subscription( self.other_account, self.domain, DefaultProductPlan.get_default_plan_version(), date_start=third_sub.date_end, ) deactivate_subscriptions(third_sub.date_end) account_credits = self._ensure_transfer(third_credits) for credit_line in account_credits: self.assertIsNone(credit_line.subscription) self.assertEqual(credit_line.account.pk, self.account.pk)
def make_new_enterprise_subscription(self, domain): account, _ = BillingAccount.get_or_create_account_by_domain( domain.name, account_type=BillingAccountType.CONTRACT, created_by="management command", ) Subscription.new_domain_subscription( account, domain.name, self.enterprise_plan_version, )
def generate_domain_subscription(account, domain, date_start, date_end, plan_version=None, service_type=SubscriptionType.NOT_SET): subscriber, _ = Subscriber.objects.get_or_create(domain=domain.name) subscription = Subscription( account=account, plan_version=plan_version or subscribable_plan_version(), subscriber=subscriber, date_start=date_start, date_end=date_end, service_type=service_type, ) subscription.save() return subscription
def subscription(self): """ If we're arriving here, it's because there wasn't a subscription for the period of this invoice, so let's create one. """ subscriber, _ = Subscriber.objects.get_or_create(domain=self.domain.name) subscription = Subscription( account=self.account, subscriber=subscriber, plan_version=self.software_plan_version, date_start=self.date_start, date_end=self.date_end, ) subscription.save() return subscription
def test_app_icon_permissions(self): LOGO_HOME = u'hq_logo_android_home' LOGO_LOGIN = u'hq_logo_android_login' advanced_sub = Subscription.new_domain_subscription( self.account, self.domain.name, self.advanced_plan, web_user=self.admin_user.username ) with open(os.path.join(os.path.dirname(__file__), 'data', 'app-commcare-icon-standard.json')) as f: standard_source = json.load(f) with open(os.path.join(os.path.dirname(__file__), 'data', 'app-commcare-icon-build.json')) as f: build_source = json.load(f) app_standard = Application.wrap(standard_source) app_standard.save() self.assertEqual(self.domain.name, app_standard.domain) app_build = Application.wrap(build_source) app_build.save() self.assertEqual(self.domain.name, app_build.domain) self.assertTrue(LOGO_HOME in app_standard.logo_refs.keys()) self.assertTrue(LOGO_LOGIN in app_standard.logo_refs.keys()) self.assertTrue(LOGO_HOME in app_build.logo_refs.keys()) self.assertTrue(LOGO_LOGIN in app_build.logo_refs.keys()) advanced_sub.cancel_subscription(web_user=self.admin_user.username) app_standard = Application.get(app_standard._id) app_build = Application.get(app_build._id) self.assertFalse(LOGO_HOME in app_standard.logo_refs.keys()) self.assertFalse(LOGO_LOGIN in app_standard.logo_refs.keys()) self.assertFalse(LOGO_HOME in app_build.logo_refs.keys()) self.assertFalse(LOGO_LOGIN in app_build.logo_refs.keys()) Subscription.new_domain_subscription( self.account, self.domain.name, self.advanced_plan, web_user=self.admin_user.username ) app_standard = Application.get(app_standard._id) app_build = Application.get(app_build._id) self.assertTrue(LOGO_HOME in app_standard.logo_refs.keys()) self.assertTrue(LOGO_LOGIN in app_standard.logo_refs.keys()) self.assertTrue(LOGO_HOME in app_build.logo_refs.keys()) self.assertTrue(LOGO_LOGIN in app_build.logo_refs.keys())
def save(self, commit=True): try: billing_contact_info = super(BillingAccountInfoForm, self).save(commit=False) billing_contact_info.account = self.account billing_contact_info.save() billing_admins = self.cleaned_data['billing_admins'] for admin in billing_admins: if not self.account.billing_admins.filter(web_user=admin.web_user).exists(): self.account.billing_admins.add(admin) self.account.save() if self.current_subscription is not None: if self.plan_version.plan.edition == SoftwarePlanEdition.COMMUNITY: self.current_subscription.cancel_subscription(adjustment_method=SubscriptionAdjustmentMethod.USER, web_user=self.creating_user) else: subscription = self.current_subscription.change_plan( self.plan_version, web_user=self.creating_user, adjustment_method=SubscriptionAdjustmentMethod.USER ) subscription.is_active = True subscription.save() else: subscription = Subscription.new_domain_subscription( self.account, self.domain, self.plan_version, web_user=self.creating_user, adjustment_method=SubscriptionAdjustmentMethod.USER ) subscription.is_active = True subscription.save() return True except Exception: logger.exception("There was an error subscribing the domain '%s' to plan '%s'. " "Go quickly!" % (self.domain, self.plan_version.plan.name)) return False
def setUp(self): super(OptTestCase, self).setUp() self.domain = "opt-test" self.domain_obj = Domain(name=self.domain) self.domain_obj.save() generator.instantiate_accounting_for_tests() self.account = BillingAccount.get_or_create_account_by_domain( self.domain_obj.name, created_by="automated-test", )[0] plan = DefaultProductPlan.get_default_plan_by_domain( self.domain_obj, edition=SoftwarePlanEdition.ADVANCED ) self.subscription = Subscription.new_domain_subscription( self.account, self.domain_obj.name, plan ) self.subscription.is_active = True self.subscription.save() self.backend = TestSMSBackend(is_global=True) self.backend.save() self.backend_mapping = BackendMapping( is_global=True, prefix="*", backend_id=self.backend._id, ) self.backend_mapping.save()
def test_transfers(self): advanced_plan = DefaultProductPlan.get_default_plan_by_domain(self.domain, edition=SoftwarePlanEdition.ADVANCED) standard_plan = DefaultProductPlan.get_default_plan_by_domain(self.domain, edition=SoftwarePlanEdition.STANDARD) first_sub = Subscription.new_domain_subscription(self.account, self.domain, advanced_plan) product_credit = CreditLine.add_credit( self.product_credit_amt, subscription=first_sub, product_type=SoftwareProductType.COMMCARE ) feature_credit = CreditLine.add_credit( self.feature_credit_amt, subscription=first_sub, feature_type=FeatureType.USER ) subscription_credit = CreditLine.add_credit(self.subscription_credit_amt, subscription=first_sub) original_credits = [product_credit, feature_credit, subscription_credit] second_sub = first_sub.change_plan(standard_plan) second_credits = self._ensure_transfer(original_credits) for credit_line in second_credits: self.assertEqual(credit_line.subscription.pk, second_sub.pk) second_sub.date_end = datetime.date.today() + datetime.timedelta(days=5) second_sub.save() third_sub = second_sub.renew_subscription() third_credits = self._ensure_transfer(second_credits) for credit_line in third_credits: self.assertEqual(credit_line.subscription.pk, third_sub.pk) third_sub.cancel_subscription() account_credits = self._ensure_transfer(third_credits) for credit_line in account_credits: self.assertIsNone(credit_line.subscription) self.assertEqual(credit_line.account.pk, self.account.pk)
def _change_to_probono(self, domain_name, pro_bono_status): subscription = Subscription.get_active_subscription_by_domain(domain_name) subscription.update_subscription( pro_bono_status=pro_bono_status, date_start=datetime.date.today() - datetime.timedelta(days=1), date_end=datetime.date.today() + datetime.timedelta(days=5) )
def handle(self, *args, **options): if len(args) != 1: print "Invalid arguments: %s" % str(args) return domain = Domain.get_by_name(args[0]) if not domain: print "Invalid domain name: %s" % args[0] return account, _ = BillingAccount.get_or_create_account_by_domain( domain.name, account_type=BillingAccountType.CONTRACT, created_by="management command", ) enterprise_plan_version = SoftwarePlanVersion.objects.filter( plan__edition=SoftwarePlanEdition.ENTERPRISE )[0] try: subscription = Subscription.new_domain_subscription( account, domain.name, enterprise_plan_version ) except NewSubscriptionError as e: print e.message return subscription.is_active = True subscription.save() print 'Domain %s has been upgraded to enterprise level.' % domain.name
def create_domain(self, domain): domain_obj = Domain(name=domain) domain_obj.use_default_sms_response = True domain_obj.default_sms_response = "Default SMS Response" domain_obj.save() # I tried making this class inherit from BaseSMSTest, but somehow # the multiple inheritance was causing the postgres connection to # get in a weird state where it wasn't commiting any changes. So # for now, keeping this subscription setup code as is. generator.instantiate_accounting_for_tests() self.account = BillingAccount.get_or_create_account_by_domain( domain_obj.name, created_by="automated-test", )[0] plan = DefaultProductPlan.get_default_plan_by_domain( domain_obj, edition=SoftwarePlanEdition.ADVANCED ) self.subscription = Subscription.new_domain_subscription( self.account, domain_obj.name, plan ) self.subscription.is_active = True self.subscription.save() return domain_obj
def create_30_day_trial(domain_obj): from corehq.apps.accounting.models import ( DefaultProductPlan, SoftwarePlanEdition, BillingAccount, Currency, BillingAccountType, Subscription, SubscriptionAdjustmentMethod, ) # Create a 30 Day Trial subscription to the Advanced Plan advanced_plan_version = DefaultProductPlan.get_default_plan_by_domain( domain_obj, edition=SoftwarePlanEdition.ADVANCED, is_trial=True ) expiration_date = date.today() + timedelta(days=30) trial_account = BillingAccount.objects.get_or_create( name="Trial Account for %s" % domain_obj.name, currency=Currency.get_default(), created_by_domain=domain_obj.name, account_type=BillingAccountType.TRIAL, )[0] trial_subscription = Subscription.new_domain_subscription( trial_account, domain_obj.name, advanced_plan_version, date_end=expiration_date, adjustment_method=SubscriptionAdjustmentMethod.TRIAL, is_trial=True, ) trial_subscription.is_active = True trial_subscription.save()
def assign_explicit_community_subscription(domain_name, start_date, method, account=None, web_user=None): future_subscriptions = Subscription.visible_objects.filter( date_start__gt=start_date, subscriber__domain=domain_name, ) if future_subscriptions.exists(): end_date = future_subscriptions.earliest('date_start').date_start else: end_date = None if account is None: account = BillingAccount.get_or_create_account_by_domain( domain_name, created_by='assign_explicit_community_subscriptions', entry_point=EntryPoint.SELF_STARTED, )[0] return Subscription.new_domain_subscription( account=account, domain=domain_name, plan_version=DefaultProductPlan.get_default_plan_version(), date_start=start_date, date_end=end_date, skip_invoicing_if_no_feature_charges=True, adjustment_method=method, internal_change=True, service_type=SubscriptionType.PRODUCT, web_user=web_user, )
def run_downgrade_process(today=None): today = today or datetime.date.today() for domain, oldest_unpaid_invoice, total in _get_domains_with_invoices_over_threshold(today): current_subscription = Subscription.get_active_subscription_by_domain(domain) if _is_subscription_eligible_for_downgrade_process(current_subscription): _apply_downgrade_process(current_subscription, oldest_unpaid_invoice, total, today)
def setUp(self): super(TestDeleteDomain, self).setUp() self.domain = Domain(name="test", is_active=True) self.domain.save() self.domain.convert_to_commtrack() self.current_subscription = Subscription.new_domain_subscription( BillingAccount.get_or_create_account_by_domain(self.domain.name, created_by='tests')[0], self.domain.name, DefaultProductPlan.get_default_plan_version(SoftwarePlanEdition.ADVANCED), date_start=date.today() - relativedelta(days=1), ) self.domain2 = Domain(name="test2", is_active=True) self.domain2.save() self.domain2.convert_to_commtrack() LocationType.objects.create( domain='test', name='facility', ) LocationType.objects.create( domain='test2', name='facility', ) LocationType.objects.create( domain='test', name='facility2', ) LocationType.objects.create( domain='test2', name='facility2', )
def _change_to_extended_trial(self, domain_name): subscription = Subscription.get_active_subscription_by_domain(domain_name) subscription.update_subscription( service_type=SubscriptionType.EXTENDED_TRIAL, date_start=datetime.date.today() - datetime.timedelta(days=1), date_end=datetime.date.today() + datetime.timedelta(days=5) )
def test_update_billing_account_entry_point_contracted(self): contracted_subscription = Subscription.new_domain_subscription( self.account, self.domain.name, self.advanced_plan, web_user=self.admin_user_name, service_type=SubscriptionType.IMPLEMENTATION ) self.assertNotEqual(contracted_subscription.account.entry_point, EntryPoint.SELF_STARTED)
def assign_explicit_community_subscription(domain_name, start_date): future_subscriptions = Subscription.objects.filter( CONSISTENT_DATES_CHECK ).filter( date_start__gt=start_date, subscriber__domain=domain_name, ) if future_subscriptions.exists(): end_date = future_subscriptions.latest('date_start').date_start else: end_date = None return Subscription.new_domain_subscription( account=BillingAccount.get_or_create_account_by_domain( domain_name, created_by='assign_explicit_community_subscriptions', entry_point=EntryPoint.SELF_STARTED, )[0], domain=domain_name, plan_version=DefaultProductPlan.get_default_plan_version(), date_start=start_date, date_end=end_date, skip_invoicing_if_no_feature_charges=True, adjustment_method=SubscriptionAdjustmentMethod.TASK, internal_change=True, service_type=SubscriptionType.PRODUCT, )
def setUp(self): super(TestRenewSubscriptions, self).setUp() self.domain = Domain( name="test-domain-sub", is_active=True, ) self.domain.save() self.admin_user = generator.arbitrary_web_user() self.admin_user.add_domain_membership(self.domain.name, is_admin=True) self.admin_user.save() self.account = BillingAccount.get_or_create_account_by_domain( self.domain.name, created_by=self.admin_user.username)[0] self.standard_plan = DefaultProductPlan.get_default_plan_by_domain( self.domain.name, edition=SoftwarePlanEdition.STANDARD) today = datetime.date.today() yesterday = today + datetime.timedelta(days=-1) tomorrow = today + datetime.timedelta(days=1) self.subscription = Subscription.new_domain_subscription( self.account, self.domain.name, self.standard_plan, web_user=self.admin_user.username, date_start=yesterday, date_end=tomorrow, ) self.subscription.save()
def setUp(self): super(BaseReminderTestCase, self).setUp() self.domain_obj = Domain(name="test") self.domain_obj.save() # Prevent resource conflict self.domain_obj = Domain.get(self.domain_obj._id) self.account, _ = BillingAccount.get_or_create_account_by_domain( self.domain_obj.name, created_by="tests" ) advanced_plan_version = DefaultProductPlan.get_default_plan_by_domain( self.domain_obj, edition=SoftwarePlanEdition.ADVANCED) self.subscription = Subscription.new_domain_subscription( self.account, self.domain_obj.name, advanced_plan_version ) self.subscription.is_active = True self.subscription.save() self.sms_backend = TestSMSBackend(named="MOBILE_BACKEND_TEST", is_global=True) self.sms_backend.save() self.sms_backend_mapping = BackendMapping(is_global=True,prefix="*",backend_id=self.sms_backend._id) self.sms_backend_mapping.save()
def save(self, commit=True): account_save_success = super(ConfirmNewSubscriptionForm, self).save(commit=False) if not account_save_success: return False try: if self.current_subscription is not None: if self.plan_version.plan.edition == SoftwarePlanEdition.COMMUNITY: self.current_subscription.cancel_subscription(adjustment_method=SubscriptionAdjustmentMethod.USER, web_user=self.creating_user) else: subscription = self.current_subscription.change_plan( self.plan_version, web_user=self.creating_user, adjustment_method=SubscriptionAdjustmentMethod.USER ) subscription.is_active = True subscription.save() else: subscription = Subscription.new_domain_subscription( self.account, self.domain, self.plan_version, web_user=self.creating_user, adjustment_method=SubscriptionAdjustmentMethod.USER) subscription.is_active = True if subscription.plan_version.plan.edition == SoftwarePlanEdition.ENTERPRISE: # this point can only be reached if the initiating user was a superuser subscription.do_not_invoice = True subscription.save() return True except Exception: logger.exception("There was an error subscribing the domain '%s' to plan '%s'. " "Go quickly!" % (self.domain, self.plan_version.plan.name)) return False
def domain_is_on_trial(domain_name): from corehq.apps.accounting.models import Subscription subscription = Subscription.get_active_subscription_by_domain(domain_name) return subscription and subscription.is_trial
def setUpClass(cls): super().setUpClass() plan = DefaultProductPlan.get_default_plan_version( edition=SoftwarePlanEdition.ADVANCED) cls.blocked_account = generator.billing_account( '*****@*****.**', '*****@*****.**') cls.blocked_account.block_hubspot_data_for_all_users = True cls.blocked_account.save() # this is one domain linked to the billing account that blocks hubspot cls.blocked_domain = create_domain('block-domain-hubspot') first_blocked_sub = Subscription.new_domain_subscription( cls.blocked_account, cls.blocked_domain.name, plan) first_blocked_sub.is_active = True first_blocked_sub.save() # this is another domain linked to the billing account that blocks hubspot cls.second_blocked_domain = create_domain('block-domain-hubspot-002') second_blocked_sub = Subscription.new_domain_subscription( cls.blocked_account, cls.second_blocked_domain.name, plan) second_blocked_sub.is_active = True second_blocked_sub.save() # this domain is not linked to an account that is blocking hubspot cls.allowed_domain = create_domain('allow-domain-hubspot') allowed_account = generator.billing_account('*****@*****.**', '*****@*****.**') allowed_sub = Subscription.new_domain_subscription( allowed_account, cls.allowed_domain.name, plan) allowed_sub.is_active = True allowed_sub.save() cls.allowed_user = WebUser.create(cls.allowed_domain.name, '*****@*****.**', '*****', None, None) cls.allowed_user.save() cls.blocked_user = WebUser.create(cls.blocked_domain.name, '*****@*****.**', '*****', None, None) cls.blocked_user.save() cls.blocked_couch_user = CouchUser.get_by_username( cls.blocked_user.username) cls.second_blocked_user = WebUser.create( cls.second_blocked_domain.name, '*****@*****.**', '*****', None, None) cls.second_blocked_user.save() cls.second_blocked_couch_user = CouchUser.get_by_username( cls.second_blocked_user.username) cls.blocked_invitation_user = WebUser.create( cls.blocked_domain.name, '*****@*****.**', '*****', None, None) invite_to_blocked_domain = Invitation( email=cls.blocked_invitation_user.username, is_accepted=True, domain=cls.blocked_domain.name, invited_on=datetime.now(), invited_by="*****@*****.**", ) invite_to_blocked_domain.save() cls.blocked_commcare_user = CommCareUser.create( cls.blocked_domain.name, 'testuser', '****', None, None) cls.blocked_commcare_user.save()
def is_domain_enterprise(domain): subscription = Subscription.get_active_subscription_by_domain(domain) try: return subscription.plan_version.plan.edition == SoftwarePlanEdition.ENTERPRISE except AttributeError: return False
def update_subscription(self, plan): current_subscription = Subscription.get_active_subscription_by_domain( self.domain) if current_subscription.plan_version.plan.edition != plan: current_subscription.change_plan( DefaultProductPlan.get_default_plan_version(plan))
def get_subscription_info(domain): subscription = Subscription.get_active_subscription_by_domain(domain) if subscription: return subscription.service_type, subscription.plan_version.plan.name return None, None
def setUp(self): super(BackendTestCase, self).setUp() self.domain = "test-domain" self.domain2 = "test-domain2" self.site, self.site_created = self.get_or_create_site() self.domain_obj = Domain(name=self.domain) self.domain_obj.save() generator.instantiate_accounting_for_tests() self.account = BillingAccount.get_or_create_account_by_domain( self.domain_obj.name, created_by="automated-test", )[0] plan = DefaultProductPlan.get_default_plan_by_domain( self.domain_obj, edition=SoftwarePlanEdition.ADVANCED) self.subscription = Subscription.new_domain_subscription( self.account, self.domain_obj.name, plan) self.subscription.is_active = True self.subscription.save() self.domain_obj = Domain.get( self.domain_obj._id) # Prevent resource conflict self.backend1 = TestCaseBackend(name="BACKEND1", is_global=True) self.backend1.save() self.backend2 = TestCaseBackend(name="BACKEND2", is_global=True) self.backend2.save() self.backend3 = TestCaseBackend(name="BACKEND3", is_global=True) self.backend3.save() self.backend4 = TestCaseBackend(name="BACKEND4", is_global=True) self.backend4.save() self.backend5 = TestCaseBackend(name="BACKEND5", domain=self.domain, is_global=False, authorized_domains=[]) self.backend5.save() self.backend6 = TestCaseBackend(name="BACKEND6", domain=self.domain2, is_global=False, authorized_domains=[self.domain]) self.backend6.save() self.backend7 = TestCaseBackend(name="BACKEND7", domain=self.domain2, is_global=False, authorized_domains=[]) self.backend7.save() self.backend8 = TestCaseBackend(name="BACKEND", domain=self.domain, is_global=False, authorized_domains=[]) self.backend8.save() self.backend9 = TestCaseBackend(name="BACKEND", domain=self.domain2, is_global=False, authorized_domains=[self.domain]) self.backend9.save() self.backend10 = TestCaseBackend(name="BACKEND", is_global=True) self.backend10.save() self.backend_mapping1 = BackendMapping(is_global=True, prefix="*", backend_id=self.backend1._id) self.backend_mapping1.save() self.backend_mapping2 = BackendMapping(is_global=True, prefix="1", backend_id=self.backend2._id) self.backend_mapping2.save() self.backend_mapping3 = BackendMapping(is_global=True, prefix="91", backend_id=self.backend3._id) self.backend_mapping3.save() self.backend_mapping4 = BackendMapping(is_global=True, prefix="265", backend_id=self.backend4._id) self.backend_mapping4.save() self.backend_mapping5 = BackendMapping(is_global=True, prefix="256", backend_id=self.backend5._id) self.backend_mapping5.save() self.backend_mapping6 = BackendMapping(is_global=True, prefix="25670", backend_id=self.backend6._id) self.backend_mapping6.save() self.backend_mapping7 = BackendMapping(is_global=True, prefix="25675", backend_id=self.backend7._id) self.backend_mapping7.save() self.case = CommCareCase(domain=self.domain) self.case.set_case_property("contact_phone_number", "15551234567") self.case.set_case_property("contact_phone_number_is_verified", "1") self.case.save() self.contact = CommConnectCase.wrap(self.case.to_json()) settings.SMS_LOADED_BACKENDS.append( "corehq.apps.sms.tests.TestCaseBackend")
def domain_is_on_trial(domain): from corehq.apps.accounting.models import Subscription subscription = Subscription.get_subscribed_plan_by_domain(domain)[1] return subscription.is_trial
def test_non_trial_with_previous(self): self._run_test(Subscription(is_trial=False), Subscription(is_trial=False), True) self._run_test(Subscription(is_trial=True), Subscription(is_trial=False), True)
def test_update_billing_account_entry_point_self_serve(self): self_serve_subscription = Subscription.new_domain_subscription( self.account, self.domain.name, self.advanced_plan, web_user=self.admin_user_name, service_type=SubscriptionType.PRODUCT ) self.assertEqual(self_serve_subscription.account.entry_point, EntryPoint.SELF_STARTED)
def test_regular_plan_not_added_to_customer_account(self): self.account.is_customer_billing_account = True self.assertRaises( NewSubscriptionError, lambda: Subscription.new_domain_subscription( self.account, self.domain.name, self.advanced_plan))
def _setup_accounting(cls): cls.account, _ = BillingAccount.get_or_create_account_by_domain(cls.domain.name, created_by='') plan_version = DefaultProductPlan.get_default_plan_version(SoftwarePlanEdition.STANDARD) cls.subscription = Subscription.new_domain_subscription(cls.account, cls.domain.name, plan_version)
def request_new_domain(request, form, org, domain_type=None, new_user=True): now = datetime.utcnow() current_user = CouchUser.from_django_user(request.user) commtrack_enabled = domain_type == 'commtrack' dom_req = RegistrationRequest() if new_user: dom_req.request_time = now dom_req.request_ip = get_ip(request) dom_req.activation_guid = uuid.uuid1().hex new_domain = Domain( name=form.cleaned_data['domain_name'], is_active=False, date_created=datetime.utcnow(), commtrack_enabled=commtrack_enabled, creating_user=current_user.username, secure_submissions=True, ) if form.cleaned_data.get('domain_timezone'): new_domain.default_timezone = form.cleaned_data['domain_timezone'] if org: new_domain.organization = org new_domain.hr_name = request.POST.get('domain_hrname', None) or new_domain.name if not new_user: new_domain.is_active = True # ensure no duplicate domain documents get created on cloudant new_domain.save(**get_safe_write_kwargs()) if not new_domain.name: new_domain.name = new_domain._id new_domain.save() # we need to get the name from the _id # Create a 30 Day Trial subscription to the Advanced Plan advanced_plan_version = DefaultProductPlan.get_default_plan_by_domain( new_domain, edition=SoftwarePlanEdition.ADVANCED, is_trial=True ) expiration_date = date.today() + timedelta(days=30) trial_account = BillingAccount.objects.get_or_create( name="Trial Account for %s" % new_domain.name, currency=Currency.get_default(), created_by_domain=new_domain.name, account_type=BillingAccountType.TRIAL, )[0] trial_subscription = Subscription.new_domain_subscription( trial_account, new_domain.name, advanced_plan_version, date_end=expiration_date, adjustment_method=SubscriptionAdjustmentMethod.TRIAL, is_trial=True, ) trial_subscription.is_active = True trial_subscription.save() dom_req.domain = new_domain.name if request.user.is_authenticated(): if not current_user: current_user = WebUser() current_user.sync_from_django_user(request.user) current_user.save() current_user.add_domain_membership(new_domain.name, is_admin=True) current_user.save() dom_req.requesting_user_username = request.user.username dom_req.new_user_username = request.user.username if new_user: dom_req.save() send_domain_registration_email(request.user.email, dom_req.domain, dom_req.activation_guid) else: send_global_domain_registration_email(request.user, new_domain.name) send_new_request_update_email(request.user, get_ip(request), new_domain.name, is_new_user=new_user)
def test_non_trial_with_no_previous(self): self._run_test(None, Subscription(is_trial=False), False)
def setUpClass(cls): cls.domain = initial_bootstrap(TEST_DOMAIN) db = get_db() if db.doc_exist(DOMAIN_MODULE_KEY): module_config = db.open_doc(DOMAIN_MODULE_KEY) module_map = module_config.get('module_map') if module_map: module_map[TEST_DOMAIN] = 'custom.ewsghana' else: module_config['module_map'][TEST_DOMAIN] = 'custom.ewsghana' else: module_config = db.save_doc({ '_id': DOMAIN_MODULE_KEY, 'module_map': { 'ewsghana-test-input-stock': 'custom.ewsghana' } }) db.save_doc(module_config) generator.instantiate_accounting_for_tests() account = BillingAccount.get_or_create_account_by_domain( cls.domain.name, created_by="automated-test", )[0] plan = DefaultProductPlan.get_default_plan_by_domain( cls.domain, edition=SoftwarePlanEdition.ENTERPRISE) subscription = Subscription.new_domain_subscription( account, cls.domain.name, plan) subscription.is_active = True subscription.save() cls.endpoint = MockEndpoint('http://test-api.com/', 'dummy', 'dummy') cls.api_object = EWSApi(TEST_DOMAIN, cls.endpoint) cls.api_object.prepare_commtrack_config() cls.api_object.prepare_custom_fields() cls.datapath = os.path.join(os.path.dirname(__file__), 'data') with open(os.path.join(cls.datapath, 'sample_products.json')) as f: for p in json.loads(f.read()): cls.api_object.product_sync(Product(p)) with open(os.path.join(cls.datapath, 'sample_locations.json')) as f: for loc in json.loads(f.read()): cls.api_object.location_sync(Location(loc)) cls.test_facility3 = SQLLocation.objects.get(domain=TEST_DOMAIN, site_code='tsactive') cls.testregion2 = SQLLocation.objects.get(domain=TEST_DOMAIN, site_code='testregion2') cls.rsp = SQLLocation.objects.get(domain=TEST_DOMAIN, site_code='rsp') cls.test_district = SQLLocation.objects.get(domain=TEST_DOMAIN, site_code='testdistrict') cls.username1 = 'ews_user1' cls.password1 = 'dummy' cls.web_user1 = WebUser.create(TEST_DOMAIN, cls.username1, cls.password1) cls.web_user1.eula.signed = True cls.web_user1.save() cls.username2 = 'ews_user2' cls.password2 = 'dummy' cls.web_user2 = WebUser.create(TEST_DOMAIN, cls.username2, cls.password2) cls.web_user2.get_domain_membership( TEST_DOMAIN).location_id = cls.test_facility3.location_id cls.web_user2.eula.signed = True cls.web_user2.save() cls.username3 = 'ews_user3' cls.password3 = 'dummy' cls.web_user3 = WebUser.create(TEST_DOMAIN, cls.username3, cls.password3) cls.web_user3.get_domain_membership( TEST_DOMAIN).location_id = cls.testregion2.location_id cls.web_user3.eula.signed = True cls.web_user3.save() cls.username4 = 'ews_user4' cls.password4 = 'dummy' cls.web_user4 = WebUser.create(TEST_DOMAIN, cls.username4, cls.password4) cls.web_user4.get_domain_membership( TEST_DOMAIN).location_id = cls.rsp.location_id cls.web_user4.eula.signed = True cls.web_user4.save() cls.username5 = 'ews_user5' cls.password5 = 'dummy' cls.web_user5 = WebUser.create(TEST_DOMAIN, cls.username5, cls.password5) domain_membership = cls.web_user5.get_domain_membership(TEST_DOMAIN) domain_membership.location_id = cls.test_district.location_id domain_membership.role_id = UserRole.get_read_only_role_by_domain( cls.domain.name).get_id cls.web_user5.eula.signed = True cls.web_user5.save() cls.ad = SQLProduct.objects.get(domain=TEST_DOMAIN, code='ad') cls.al = SQLProduct.objects.get(domain=TEST_DOMAIN, code='al') cls.client = Client()
def setUpClass(cls): super().setUpClass() cls.domain1, subscriber1 = generator.arbitrary_domain_and_subscriber() cls.domain2, subscriber2 = generator.arbitrary_domain_and_subscriber() cls.admin_web_user = generator.create_arbitrary_web_user_name() account = generator.billing_account(cls.admin_web_user, cls.admin_web_user) account.is_customer_billing_account = True account.save() enterprise_plan = SoftwarePlan.objects.create( name="Helping Earth INGO Enterprise Plan", description="Enterprise plan for Helping Earth", edition=SoftwarePlanEdition.ENTERPRISE, visibility=SoftwarePlanVisibility.INTERNAL, is_customer_software_plan=True, ) first_product_rate = SoftwareProductRate.objects.create( monthly_fee=3000, name="HQ Enterprise") cls.first_version = SoftwarePlanVersion.objects.create( plan=enterprise_plan, role=Role.objects.first(), product_rate=first_product_rate) cls.first_version.save() today = datetime.date.today() two_months_ago = today - datetime.timedelta(days=60) next_month = today + datetime.timedelta(days=30) subscription1 = Subscription( account=account, plan_version=cls.first_version, subscriber=subscriber1, date_start=two_months_ago, date_end=None, service_type=SubscriptionType.IMPLEMENTATION, ) subscription1.is_active = True subscription1.save() subscription2 = Subscription( account=account, plan_version=cls.first_version, subscriber=subscriber2, date_start=two_months_ago, date_end=next_month, service_type=SubscriptionType.IMPLEMENTATION, ) subscription2.is_active = True subscription2.save() new_product_rate = SoftwareProductRate.objects.create( monthly_fee=5000, name="HQ Enterprise") cls.newest_version = SoftwarePlanVersion.objects.create( plan=enterprise_plan, role=Role.objects.first(), product_rate=new_product_rate) cls.newest_version.save()
def test_transfers(self): advanced_plan = DefaultProductPlan.get_default_plan_version( edition=SoftwarePlanEdition.ADVANCED) standard_plan = DefaultProductPlan.get_default_plan_version( edition=SoftwarePlanEdition.STANDARD) first_sub = Subscription.new_domain_subscription( self.account, self.domain.name, advanced_plan, date_start=datetime.date.today() - relativedelta(days=1), ) product_credit = CreditLine.add_credit( self.product_credit_amt, subscription=first_sub, is_product=True, ) feature_credit = CreditLine.add_credit( self.feature_credit_amt, subscription=first_sub, feature_type=FeatureType.USER, ) subscription_credit = CreditLine.add_credit( self.subscription_credit_amt, subscription=first_sub, ) original_credits = [ product_credit, feature_credit, subscription_credit, ] second_sub = first_sub.change_plan(standard_plan) second_credits = self._ensure_transfer(original_credits) for credit_line in second_credits: self.assertEqual(credit_line.subscription.pk, second_sub.pk) second_sub.date_end = datetime.date.today() + datetime.timedelta( days=5) second_sub.save() third_sub = second_sub.renew_subscription() deactivate_subscriptions(second_sub.date_end) third_sub = Subscription.visible_objects.get(id=third_sub.id) third_credits = self._ensure_transfer(second_credits) for credit_line in third_credits: self.assertEqual(credit_line.subscription.pk, third_sub.pk) third_sub.date_end = third_sub.date_start + relativedelta(days=1) third_sub.save() Subscription.new_domain_subscription( self.other_account, self.domain, DefaultProductPlan.get_default_plan_version(), date_start=third_sub.date_end, ) deactivate_subscriptions(third_sub.date_end) account_credits = self._ensure_transfer(third_credits) for credit_line in account_credits: self.assertIsNone(credit_line.subscription) self.assertEqual(credit_line.account.pk, self.account.pk)
def post(self, req, *args, **kwargs): report = dict([(key, req.POST.get(key, '')) for key in ( 'subject', 'username', 'domain', 'url', 'message', 'app_id', 'cc', 'email', '500traceback', 'sentry_id', )]) try: couch_user = req.couch_user full_name = couch_user.full_name if couch_user.is_commcare_user(): email = report['email'] else: email = couch_user.get_email() except Exception: full_name = None email = report['email'] report['full_name'] = full_name report['email'] = email or report['username'] if report['domain']: domain = report['domain'] elif len(couch_user.domains) == 1: # This isn't a domain page, but the user has only one domain, so let's use that domain = couch_user.domains[0] else: domain = "<no domain>" message = ("username: {username}\n" "full name: {full_name}\n" "domain: {domain}\n" "url: {url}\n").format(**report) domain_object = Domain.get_by_name( domain) if report['domain'] else None debug_context = { 'datetime': datetime.utcnow(), 'self_started': '<unknown>', 'scale_backend': '<unknown>', 'has_handoff_info': '<unknown>', 'project_description': '<unknown>', 'sentry_error': '{}{}'.format(getattr(settings, 'SENTRY_QUERY_URL', ''), report['sentry_id']) } if domain_object: current_project_description = domain_object.project_description if domain_object else None new_project_description = req.POST.get('project_description') if (domain_object and req.couch_user.is_domain_admin(domain=domain) and new_project_description and current_project_description != new_project_description): domain_object.project_description = new_project_description domain_object.save() message += (("software plan: {software_plan}\n").format( software_plan=Subscription.get_subscribed_plan_by_domain( domain), )) debug_context.update({ 'self_started': domain_object.internal.self_started, 'scale_backend': should_use_sql_backend(domain), 'has_handoff_info': bool(domain_object.internal.partner_contact), 'project_description': domain_object.project_description, }) subject = '{subject} ({domain})'.format(subject=report['subject'], domain=domain) cc = [el for el in report['cc'].strip().split(",") if el] if full_name and not any([c in full_name for c in '<>"']): reply_to = '"{full_name}" <{email}>'.format(**report) else: reply_to = report['email'] # if the person looks like a commcare user, fogbugz can't reply # to their email, so just use the default if settings.HQ_ACCOUNT_ROOT in reply_to: reply_to = settings.SERVER_EMAIL message += "Message:\n\n{message}\n".format(message=report['message']) if req.POST.get('five-hundred-report'): extra_message = ( "This message was reported from a 500 error page! " "Please fix this ASAP (as if you wouldn't anyway)...") extra_debug_info = ( "datetime: {datetime}\n" "Is self start: {self_started}\n" "Is scale backend: {scale_backend}\n" "Has Support Hand-off Info: {has_handoff_info}\n" "Project description: {project_description}\n" "Sentry Error: {sentry_error}\n").format(**debug_context) traceback_info = cache.cache.get( report['500traceback']) or 'No traceback info available' cache.cache.delete(report['500traceback']) message = "\n\n".join( [message, extra_debug_info, extra_message, traceback_info]) email = EmailMessage(subject=subject, body=message, to=self.recipients, headers={'Reply-To': reply_to}, cc=cc) uploaded_file = req.FILES.get('report_issue') if uploaded_file: filename = uploaded_file.name content = uploaded_file.read() email.attach(filename=filename, content=content) # only fake the from email if it's an @dimagi.com account is_icds_env = settings.SERVER_ENVIRONMENT in settings.ICDS_ENVS if re.search(r'@dimagi\.com$', report['username']) and not is_icds_env: email.from_email = report['username'] else: email.from_email = settings.CCHQ_BUG_REPORT_EMAIL email.send(fail_silently=False) if req.POST.get('five-hundred-report'): messages.success( req, "Your CommCare HQ Issue Report has been sent. We are working quickly to resolve this problem." ) return HttpResponseRedirect(reverse('homepage')) return HttpResponse()
def test_get_active_domains_for_account(self): tasks.activate_subscriptions( based_on_date=self.subscription.date_start) test_domains = ['test'] domains = Subscription.get_active_domains_for_account(self.account) self.assertEqual(list(domains), test_domains)
def handle(self, *args, **options): if len(args) != 1: print "Invalid arguments: %s" % str(args) return completed = 0 total = 0 filename = args[0] with open(filename) as f: reader = csv.reader(f) reader.next() for row in reader: total = total + 1 domain = row[0] plan_version, subscription = Subscription.get_subscribed_plan_by_domain( domain) if subscription is None: print "Could not find Subscription for %s" % domain account = BillingAccount.get_account_by_domain(domain) if account is None: print "Could not find BillingAccount for %s" % domain if account is not None and subscription is not None: ''' service_type = self.normalize(row[1]) # self service, contracted, or not set if service_type == "selfservice": #print "%s service_type => SELF_SERVICE" % domain subscription.service_type = SubscriptionType.SELF_SERVICE elif service_type == "contracted": #print "%s service_type => CONTRACTED" % domain subscription.service_type = SubscriptionType.CONTRACTED elif service_type == "notset": #print "%s service_type => NOT_SET" % domain subscription.service_type = SubscriptionType.NOT_SET else: pass #print "Skipping service type for %s" % domain entry_point = self.normalize(row[2]) # yes if self starter, might be missing if entry_point == "yes": #print "%s entry_point => SELF_STARTED" % domain account.entry_point = EntryPoint.SELF_STARTED elif entry_point == "no": #print "%s entry_point => CONTRACTED" % domain account.entry_point = EntryPoint.CONTRACTED else: #print "Skipping entry point for %s" % domain pass ''' pro_bono_status = self.normalize(row[3]) # yes/no if pro_bono_status == "yes": #print "%s pro_bono_status => YES" % domain subscription.pro_bono_status = ProBonoStatus.YES elif pro_bono_status == "discounted": #print "%s pro_bono_status => DISCOUNTED" % domain subscription.pro_bono_status = ProBonoStatus.DISCOUNTED else: #print "%s pro_bono_status => NO" % domain subscription.pro_bono_status = ProBonoStatus.NO '''print "setting %s's service_type=%s, entry_point=%s, pro_bono=%s" % ( domain, subscription.service_type, account.entry_point, subscription.pro_bono_status )''' subscription.save() account.save() completed = completed + 1 print "Completed %i of %i domains" % (completed, total)
def options(self): account = BillingAccount.get_account_by_domain(self.request.domain) return clean_options([ (domain, domain) for domain in Subscription.get_active_domains_for_account(account) ])
def get_overdue_invoice(domain_name): current_subscription = Subscription.get_active_subscription_by_domain(domain_name) if current_subscription and is_subscription_eligible_for_downgrade_process(current_subscription): overdue_invoice, _ = get_oldest_unpaid_invoice_over_threshold(date.today(), domain_name) return overdue_invoice
def _subscribe_to_advanced(self): return Subscription.new_domain_subscription( self.account, self.project.name, self.advanced_plan, web_user=self.admin_username)
def get_subscription_properties_by_user(couch_user): def _is_paying_subscription(subscription, plan_version): NON_PAYING_SERVICE_TYPES = [ SubscriptionType.TRIAL, SubscriptionType.EXTENDED_TRIAL, SubscriptionType.SANDBOX, SubscriptionType.INTERNAL, ] NON_PAYING_PRO_BONO_STATUSES = [ ProBonoStatus.YES, ProBonoStatus.DISCOUNTED, ] return (plan_version.plan.visibility != SoftwarePlanVisibility.TRIAL and subscription.service_type not in NON_PAYING_SERVICE_TYPES and subscription.pro_bono_status not in NON_PAYING_PRO_BONO_STATUSES and plan_version.plan.edition != SoftwarePlanEdition.COMMUNITY) # Note: using "yes" and "no" instead of True and False because spec calls # for using these values. (True is just converted to "True" in KISSmetrics) all_subscriptions = [] paying_subscribed_editions = [] subscribed_editions = [] for domain_name in couch_user.domains: subscription = Subscription.get_active_subscription_by_domain( domain_name) plan_version = (subscription.plan_version if subscription is not None else DefaultProductPlan.get_default_plan_version()) subscribed_editions.append(plan_version.plan.edition) if subscription is not None: all_subscriptions.append(subscription) if subscription is not None and _is_paying_subscription( subscription, plan_version): paying_subscribed_editions.append(plan_version.plan.edition) def _is_one_of_editions(edition): return 'yes' if edition in subscribed_editions else 'no' def _is_a_pro_bono_status(status): return 'yes' if status in [ s.pro_bono_status for s in all_subscriptions ] else 'no' def _is_on_extended_trial(): service_types = [s.service_type for s in all_subscriptions] return 'yes' if SubscriptionType.EXTENDED_TRIAL in service_types else 'no' def _max_edition(): for edition in paying_subscribed_editions: assert edition in [e[0] for e in SoftwarePlanEdition.CHOICES] return max( paying_subscribed_editions) if paying_subscribed_editions else '' env = get_instance_string() return { '{}is_on_community_plan'.format(env): _is_one_of_editions(SoftwarePlanEdition.COMMUNITY), '{}is_on_standard_plan'.format(env): _is_one_of_editions(SoftwarePlanEdition.STANDARD), '{}is_on_pro_plan'.format(env): _is_one_of_editions(SoftwarePlanEdition.PRO), '{}is_on_pro_bono_plan'.format(env): _is_a_pro_bono_status(ProBonoStatus.YES), '{}is_on_discounted_plan'.format(env): _is_a_pro_bono_status(ProBonoStatus.DISCOUNTED), '{}is_on_extended_trial_plan'.format(env): _is_on_extended_trial(), '{}max_edition_of_paying_plan'.format(env): _max_edition() }
def plan_name(self): plan_version, _ = Subscription.get_subscribed_plan_by_domain( self.domain) return plan_version.plan.name