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 setUp(self):
super(TestNewDomainSubscription, self).setUp()
self.domain = Domain(
name="test-domain-sub",
is_active=True,
)
self.domain.save()
self.domain2 = Domain(
name="test-domain-sub2",
is_active=True,
)
self.domain2.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.account2 = BillingAccount.get_or_create_account_by_domain(
self.domain2.name, created_by=self.admin_user.username)[0]
self.standard_plan = DefaultProductPlan.get_default_plan_by_domain(
self.domain.name, edition=SoftwarePlanEdition.STANDARD)
self.advanced_plan = DefaultProductPlan.get_default_plan_by_domain(
self.domain.name, edition=SoftwarePlanEdition.ADVANCED)
def setUp(self):
super(TestSubscriptionForm, self).setUp()
self.domain = Domain(
name="test-sub-form",
is_active=True
)
self.domain.save()
self.domain2 = Domain(
name="test-sub-form-2",
is_active=True
)
self.domain2.save()
self.web_user = WebUser.create(
self.domain.name, generator.create_arbitrary_web_user_name(), 'testpwd'
)
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.web_user.username
)[0]
self.account.save()
self.customer_account = BillingAccount.get_or_create_account_by_domain(
self.domain2.name, created_by=self.web_user.username
)[0]
self.customer_account.is_customer_billing_account = True
self.customer_account.save()
self.plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
self.customer_plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
self.customer_plan.plan.is_customer_software_plan = True
def setUpClass(cls):
super(BaseCustomerInvoiceCase, cls).setUpClass()
if cls.is_using_test_plans:
generator.bootstrap_test_software_plan_versions()
cls.billing_contact = generator.create_arbitrary_web_user_name()
cls.dimagi_user = generator.create_arbitrary_web_user_name(is_dimagi=True)
cls.account = generator.billing_account(
cls.dimagi_user, cls.billing_contact)
cls.domain = generator.arbitrary_domain()
cls.account.is_customer_billing_account = True
cls.account.save()
cls.advanced_plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
cls.advanced_plan.plan.is_customer_software_plan = True
cls.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, cls.subscription_length)
cls.subscription = generator.generate_domain_subscription(
cls.account,
cls.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
advanced_subscription_end_date = add_months_to_date(subscription_end_date, 2)
cls.domain2 = generator.arbitrary_domain()
cls.sub2 = generator.generate_domain_subscription(
cls.account,
cls.domain2,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan
)
cls.domain3 = generator.arbitrary_domain()
cls.sub3 = generator.generate_domain_subscription(
cls.account,
cls.domain3,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan
)
# This subscription should not be included in any customer invoices in these tests
cls.domain_community = generator.arbitrary_domain()
cls.sub3 = generator.generate_domain_subscription(
cls.account,
cls.domain3,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.COMMUNITY)
)
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 ensure_plans(self, dry_run=False):
edition_to_features = self.ensure_features(dry_run=dry_run)
for product_type in self.product_types:
for edition in self.editions:
role_slug = self.BOOTSTRAP_EDITION_TO_ROLE[edition]
try:
role = Role.objects.get(slug=role_slug)
except ObjectDoesNotExist:
logging.info("Could not find the role '%s'. Did you forget to run cchq_prbac_bootstrap?")
logging.info("Aborting. You should figure this out.")
return
software_plan_version = SoftwarePlanVersion(role=role)
product, product_rates = self.ensure_product_and_rate(product_type, edition, dry_run=dry_run)
feature_rates = self.ensure_feature_rates(edition_to_features[edition], edition, dry_run=dry_run)
software_plan = SoftwarePlan(
name='%s Edition' % product.name, edition=edition, visibility=SoftwarePlanVisibility.PUBLIC
)
if dry_run:
logging.info("[DRY RUN] Creating Software Plan: %s" % software_plan)
else:
try:
software_plan = SoftwarePlan.objects.get(name=software_plan.name)
logging.info("Plan '%s' already exists. Using existing plan to add version."
% software_plan.name)
except ObjectDoesNotExist:
software_plan.save()
logging.info("Creating Software Plan: %s" % software_plan)
software_plan_version.plan = software_plan
software_plan_version.save()
for product_rate in product_rates:
software_plan_version.product_rates.add(product_rate)
for feature_rate in feature_rates:
software_plan_version.feature_rates.add(feature_rate)
software_plan_version.save()
default_product_plan = DefaultProductPlan(product_type=product.product_type, edition=edition)
if dry_run:
logging.info("[DRY RUN] Setting plan as default for product '%s' and edition '%s'." %
(product.product_type, default_product_plan.edition))
else:
try:
default_product_plan = DefaultProductPlan.objects.get(product_type=product.product_type,
edition=edition)
logging.info("Default for product '%s' and edition '%s' already exists." %
(product.product_type, default_product_plan.edition))
except ObjectDoesNotExist:
default_product_plan.plan = software_plan
default_product_plan.save()
logging.info("Setting plan as default for product '%s' and edition '%s'." %
(product.product_type, default_product_plan.edition))
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 wrapped(request, *args, **kwargs):
try:
if (hasattr(request, 'subscription')
and request.subscription is not None
and request.subscription.is_trial
and request.subscription.date_end is not None
):
edition_req = DefaultProductPlan.get_lowest_edition_by_domain(
request.domain, [slug]
)
plan_name = request.subscription.plan_version.user_facing_description['name']
feature_name = privileges.Titles.get_name_from_privilege(slug)
request.show_trial_notice = True
request.trial_info = {
'current_plan': plan_name,
'feature_name': feature_name,
'required_plan': edition_req,
'date_end': request.subscription.date_end.strftime(USER_DATE_FORMAT)
}
request.is_billing_admin = (hasattr(request, 'couch_user')
and BillingAccountAdmin.get_admin_status_and_account(
request.couch_user, request.domain
)[0])
return requires_privilege(slug, **assignment)(fn)(
request, *args, **kwargs
)
except PermissionDenied:
request.show_trial_notice = False
from corehq.apps.domain.views import SubscriptionUpgradeRequiredView
return SubscriptionUpgradeRequiredView().get(
request, request.domain, slug
)
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 _test_plan_versions_ensured(self, bootstrap_config):
ensure_plans(bootstrap_config, True, apps)
for (edition, is_trial, has_report_builder), config in six.iteritems(bootstrap_config):
software_plan_version = DefaultProductPlan.get_default_plan_version(
edition=edition, is_trial=is_trial, is_report_builder_enabled=has_report_builder
)
self.assertEqual(software_plan_version.role.slug, config['role'])
self.assertEqual(software_plan_version.product_rate.monthly_fee, config['product_rate_monthly_fee'])
self.assertEqual(
software_plan_version.user_limit,
config['feature_rates'][FeatureType.USER]['monthly_limit']
)
self.assertEqual(
software_plan_version.user_feature.per_excess_fee,
config['feature_rates'][FeatureType.USER]['per_excess_fee']
)
sms_feature_rate = software_plan_version.feature_rates.get(feature__feature_type=FeatureType.SMS)
self.assertEqual(
sms_feature_rate.monthly_limit,
config['feature_rates'][FeatureType.SMS]['monthly_limit']
)
self.assertEqual(sms_feature_rate.per_excess_fee, 0)
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 cancel_subscription(self):
self.subscription.change_plan(
new_plan_version=DefaultProductPlan.get_default_plan_version(),
note=self.cancel_form.cleaned_data['note'],
web_user=self.request.user.username,
)
self.subscription_canceled = True
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):
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 _init_pro_with_rb_plan_and_version(self):
plan = SoftwarePlan(
name="Pro_with_30_RB_reports",
description="Pro + 30 report builder reports",
edition=SoftwarePlanEdition.PRO,
visibility=SoftwarePlanVisibility.INTERNAL,
)
plan.save()
role = Role.objects.create(
slug="pro_with_rb_30_role",
name="Pro + 30 rb reports",
)
for privilege in [privileges.REPORT_BUILDER_30]: # Doesn't actually include the pro roles...
privilege = Role.objects.get(slug=privilege)
Grant.objects.create(
from_role=role,
to_role=privilege,
)
self.pro_rb_version = SoftwarePlanVersion(
plan=plan,
role=role
)
self.pro_rb_version.product_rate = DefaultProductPlan.get_default_plan_version(
SoftwarePlanEdition.PRO
).product_rate
self.pro_rb_version.save()
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 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 setUp(self):
super(TestUserRoleSubscriptionChanges, self).setUp()
self.domain = generator.arbitrary_domain()
UserRole.init_domain_with_presets(self.domain.name)
self.user_roles = UserRole.by_domain(self.domain.name)
self.custom_role = UserRole.get_or_create_with_permissions(
self.domain.name,
Permissions(edit_apps=True, edit_web_users=True),
"Custom Role"
)
self.custom_role.save()
self.read_only_role = UserRole.get_read_only_role_by_domain(self.domain.name)
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.domain.name, is_admin=True)
self.admin_user.save()
self.web_users = []
self.commcare_users = []
for role in [self.custom_role] + self.user_roles:
web_user = generator.arbitrary_web_user()
web_user.add_domain_membership(self.domain.name, role_id=role.get_id)
web_user.save()
self.web_users.append(web_user)
commcare_user = generator.arbitrary_commcare_user(
domain=self.domain.name)
commcare_user.set_role(self.domain.name, role.get_qualified_id())
commcare_user.save()
self.commcare_users.append(commcare_user)
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name,created_by=self.admin_user.username)[0]
self.advanced_plan = DefaultProductPlan.get_default_plan_by_domain(
self.domain.name,edition=SoftwarePlanEdition.ADVANCED)
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()
new_subscription = subscription.change_plan(DefaultProductPlan.get_default_plan_version())
custom_role = UserRole.get(self.custom_role.get_id)
self.assertTrue(custom_role.is_archived)
new_subscription.change_plan(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()
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_community_over_limit(self):
"""
For a domain under community (no subscription) with users over the community limit, make sure that:
- base_description is None
- base_cost is 0.0
- unit_description is not None
- unit_cost is equal to the per_excess_fee on the user rate
- quantity is equal to number of commcare users in that domain minus the monthly_limit on the user rate
- total and subtotals are equal to number of extra users * per_excess_fee
"""
domain = generator.arbitrary_domain()
num_active = generator.create_excess_community_users(domain)
account = BillingAccount.get_or_create_account_by_domain(
domain, created_by=self.dimagi_user)[0]
billing_contact = generator.arbitrary_contact_info(account, self.dimagi_user)
account.date_confirmed_extra_charges = datetime.date.today()
account.save()
tasks.generate_invoices()
subscriber = Subscriber.objects.get(domain=domain.name)
invoice = Invoice.objects.filter(subscription__subscriber=subscriber).get()
user_line_item = invoice.lineitem_set.get_feature_by_type(FeatureType.USER).get()
self.assertIsNone(user_line_item.base_description)
self.assertEqual(user_line_item.base_cost, Decimal('0.0000'))
community_plan = DefaultProductPlan.get_default_plan_version()
num_to_charge = num_active - community_plan.user_limit
self.assertIsNotNone(user_line_item.unit_description)
self.assertEqual(user_line_item.quantity, num_to_charge)
self.assertEqual(user_line_item.unit_cost, self.user_rate.per_excess_fee)
self.assertEqual(user_line_item.subtotal, num_to_charge * self.user_rate.per_excess_fee)
self.assertEqual(user_line_item.total, num_to_charge * self.user_rate.per_excess_fee)
domain.delete()
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 _downgrade_domain(subscription):
subscription.change_plan(
DefaultProductPlan.get_default_plan_version(
SoftwarePlanEdition.COMMUNITY
),
note='Automatic downgrade to community for invoice 60 days late',
internal_change=True
)
def test_app_icon_permissions(self):
LOGO_HOME = 'hq_logo_android_home'
LOGO_LOGIN = '******'
advanced_sub = self._subscribe_to_advanced()
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.project.name, app_standard.domain)
app_build = Application.wrap(build_source)
app_build.save()
self.assertEqual(self.project.name, app_build.domain)
self.assertTrue(LOGO_HOME in app_standard.logo_refs)
self.assertTrue(LOGO_LOGIN in app_standard.logo_refs)
self.assertTrue(LOGO_HOME in app_build.logo_refs)
self.assertTrue(LOGO_LOGIN in app_build.logo_refs)
community_sub = advanced_sub.change_plan(DefaultProductPlan.get_default_plan_version())
app_standard = Application.get(app_standard._id)
app_build = Application.get(app_build._id)
self.assertFalse(LOGO_HOME in app_standard.logo_refs)
self.assertFalse(LOGO_LOGIN in app_standard.logo_refs)
self.assertFalse(LOGO_HOME in app_build.logo_refs)
self.assertFalse(LOGO_LOGIN in app_build.logo_refs)
community_sub.change_plan(
DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
)
app_standard = Application.get(app_standard._id)
app_build = Application.get(app_build._id)
self.assertTrue(LOGO_HOME in app_standard.logo_refs)
self.assertTrue(LOGO_LOGIN in app_standard.logo_refs)
self.assertTrue(LOGO_HOME in app_build.logo_refs)
self.assertTrue(LOGO_LOGIN in app_build.logo_refs)
def _downgrade_domain(subscription):
subscription.change_plan(
DefaultProductPlan.get_default_plan_version(
SoftwarePlanEdition.COMMUNITY
),
adjustment_method=SubscriptionAdjustmentMethod.AUTOMATIC_DOWNGRADE,
note='Automatic downgrade to community for invoice 60 days late',
internal_change=True
)
def test_change_plan_on_renewal(self):
new_edition = SoftwarePlanEdition.ADVANCED
new_plan = DefaultProductPlan.get_default_plan_by_domain(self.domain.name, new_edition)
self.renewed_subscription = self.subscription.renew_subscription(
new_version=new_plan
)
self.assertEqual(self.renewed_subscription.plan_version, new_plan)
def setup_subscription(cls, domain_name, software_plan):
generator.instantiate_accounting()
plan = DefaultProductPlan.get_default_plan_version(edition=software_plan)
cls.account = BillingAccount.get_or_create_account_by_domain(
domain_name, created_by="automated-test" + cls.__name__
)[0]
cls.subscription = Subscription.new_domain_subscription(cls.account, domain_name, plan)
cls.subscription.is_active = True
cls.subscription.save()
def setUp(self):
super(TestSoftwarePlanChanges, self).setUp()
self.domain = Domain(
name="test-plan-changes",
is_active=True,
)
self.domain.save()
self.domain2 = Domain(
name="other-domain",
is_active=True,
)
self.domain2.save()
self.admin_username = generator.create_arbitrary_web_user_name()
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.admin_username)[0]
self.advanced_plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
self.advanced_plan.plan.max_domains = 1
self.community_plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.COMMUNITY)
def setUp(self):
self._clear_docs()
self.domain = create_domain(DOMAIN)
self.account = BillingAccount.get_or_create_account_by_domain(DOMAIN, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_by_domain(DOMAIN, edition=SoftwarePlanEdition.ADVANCED)
self.subscription = Subscription.new_domain_subscription(self.account, DOMAIN, plan)
self.subscription.is_active = True
self.subscription.save()
self.couch_user = WebUser.create(None, "test", "foobar")
self.couch_user.add_domain_membership(DOMAIN, is_admin=True)
self.couch_user.save()
def setUpClass(cls):
super(TestOdataFeed, cls).setUpClass()
cls.client = Client()
cls.domain = Domain(name='test_domain')
cls.domain.save()
cls.web_user = WebUser.create(cls.domain.name, 'test_user', 'my_password')
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 _generate_invoice_and_subscription(days_ago,
is_customer_billing_account=False):
"""
:param days_ago: The number of days ago an invoice should be due
:return: random domain, with invoices generated on the backend
"""
invoice_due_date = datetime.date.today() - datetime.timedelta(
days=days_ago)
billing_contact = generator.create_arbitrary_web_user_name()
dimagi_user = generator.create_arbitrary_web_user_name(is_dimagi=True)
account = generator.billing_account(dimagi_user, billing_contact)
account.is_customer_billing_account = is_customer_billing_account
account.save()
domain = generator.arbitrary_domain()
subscription_start_date = utils.months_from_date(invoice_due_date, -2)
subscription = generator.generate_domain_subscription(
account,
domain,
date_start=subscription_start_date,
date_end=None,
plan_version=DefaultProductPlan.get_default_plan_version(
SoftwarePlanEdition.ADVANCED),
service_type=SubscriptionType.PRODUCT,
)
subscription.is_active = True
subscription.save()
invoice_date = utils.months_from_date(invoice_due_date, -1)
DomainUserHistory.objects.create(domain=domain.name,
num_users=20,
record_date=invoice_date -
datetime.timedelta(days=1))
tasks.generate_invoices(invoice_date)
# for testing purposes, force the latest invoice due_date to be
# the "invoice_due_date" specified above
if is_customer_billing_account:
latest_invoice = CustomerInvoice.objects.filter(
account=account, ).latest('date_created')
else:
latest_invoice = subscription.invoice_set.latest('date_created')
latest_invoice.date_due = invoice_due_date
latest_invoice.save()
return domain, latest_invoice
def setUp(self):
super(TestUserRoleSubscriptionChanges, self).setUp()
self.domain = Domain(
name="test-sub-changes",
is_active=True,
)
self.domain.save()
self.other_domain = Domain(
name="other-domain",
is_active=True,
)
self.other_domain.save()
initialize_domain_with_default_roles(self.domain.name)
self.user_roles = UserRole.objects.get_by_domain(self.domain.name)
self.custom_role = UserRole.create(
self.domain.name,
"Custom Role",
permissions=Permissions(
edit_apps=True,
view_apps=True,
edit_web_users=True,
view_web_users=True,
view_roles=True,
)
)
self.admin_username = generator.create_arbitrary_web_user_name()
self.web_users = []
self.commcare_users = []
for role in [self.custom_role] + self.user_roles:
web_user = WebUser.create(
self.other_domain.name, generator.create_arbitrary_web_user_name(), 'test123', None, None
)
web_user.is_active = True
web_user.add_domain_membership(self.domain.name, role_id=role.get_id)
web_user.save()
self.web_users.append(web_user)
commcare_user = generator.arbitrary_commcare_user(
domain=self.domain.name)
commcare_user.set_role(self.domain.name, role.get_qualified_id())
commcare_user.save()
self.commcare_users.append(commcare_user)
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.admin_username)[0]
self.advanced_plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
def prepare_domain(domain_name):
from corehq.apps.commtrack.tests import bootstrap_domain
domain = bootstrap_domain(domain_name)
def _make_loc_type(name, administrative=False, parent_type=None):
return LocationType.objects.get_or_create(
domain=domain_name,
name=name,
administrative=administrative,
parent_type=parent_type,
)[0]
country = _make_loc_type(name="country", administrative=True)
_make_loc_type(name="Central Medical Store", parent_type=country)
_make_loc_type(name="Teaching Hospital", parent_type=country)
region = _make_loc_type(name="region",
administrative=True,
parent_type=country)
_make_loc_type(name="Regional Medical Store", parent_type=region)
_make_loc_type(name="Regional Hospital", parent_type=region)
district = _make_loc_type(name="district",
administrative=True,
parent_type=region)
_make_loc_type(name="Clinic", parent_type=district)
_make_loc_type(name="District Hospital", parent_type=district)
_make_loc_type(name="Health Centre", parent_type=district)
_make_loc_type(name="CHPS Facility", parent_type=district)
_make_loc_type(name="Hospital", parent_type=district)
_make_loc_type(name="Psychiatric Hospital", parent_type=district)
_make_loc_type(name="Polyclinic", parent_type=district)
_make_loc_type(name="facility", parent_type=district)
generator.instantiate_accounting_for_tests()
account = BillingAccount.get_or_create_account_by_domain(
domain.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan_by_domain(
domain, edition=SoftwarePlanEdition.ADVANCED)
subscription = Subscription.new_domain_subscription(
account, domain.name, plan)
subscription.is_active = True
subscription.save()
ews_config = EWSGhanaConfig(enabled=True, domain=domain.name)
ews_config.save()
return domain
def setUp(self):
super(TestDomainInvoiceFactory, self).setUp()
self.invoice_start, self.invoice_end = get_previous_month_date_range()
self.domain = generator.arbitrary_domain()
self.account = BillingAccount.get_or_create_account_by_domain(
domain=self.domain.name, created_by="TEST"
)[0]
self.community = DefaultProductPlan.get_default_plan_version()
generator.arbitrary_commcare_users_for_domain(
self.domain.name, self.community.user_limit + 1
)
self.invoice_factory = DomainInvoiceFactory(
self.invoice_start, self.invoice_end, self.domain
)
def bootrap_domain_for_zapier(domain_name):
domain_object = Domain.get_or_create_with_name(domain_name, is_active=True)
account = BillingAccount.get_or_create_account_by_domain(
domain_name, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.STANDARD)
subscription = Subscription.new_domain_subscription(
account, domain_name, plan)
subscription.is_active = True
subscription.save()
web_user = WebUser.create(domain_name, 'test', '******', None, None)
api_key_object, _ = HQApiKey.objects.get_or_create(
user=web_user.get_django_user())
return ZapierDomainConfig(domain_object, web_user, api_key_object.key)
def setUp(self):
super(TestSubscriptionPermissionsChanges, self).setUp()
self.project = Domain(
name="test-sub-changes",
is_active=True,
)
self.project.save()
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.project.name, is_admin=True)
self.admin_user.save()
self.account = BillingAccount.get_or_create_account_by_domain(
self.project.name, created_by=self.admin_user.username)[0]
self.advanced_plan = DefaultProductPlan.get_default_plan(edition=SoftwarePlanEdition.ADVANCED)
self._init_pro_with_rb_plan_and_version()
def handle(self, *args, **kwargs):
domain_names = args
privileges = sorted(_privilege_to_response_function().keys())
print(','.join(['Project Space'] + privileges + ['Lowest Plan']))
for domain in filter(lambda domain: domain, map(Domain.get_by_name, domain_names)):
is_privilege_being_used = {
priv: _is_domain_using_privilege(domain, priv)
for priv in privileges
}
using_privileges = [priv for (priv, is_in_use) in is_privilege_being_used.items() if is_in_use]
minimum_plan = DefaultProductPlan.get_lowest_edition(using_privileges)
print(','.join(
[domain.name] +
['X' if is_privilege_being_used[priv] else '' for priv in privileges] +
[minimum_plan]
))
def setup_domain(cls, name):
domain_obj = Domain(name=name,
sms_mobile_worker_registration_enabled=True)
domain_obj.save()
plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED)
account = BillingAccount.get_or_create_account_by_domain(
name, created_by="automated-test-" + cls.__name__)[0]
subscription = Subscription.new_domain_subscription(
account, name, plan)
subscription.is_active = True
subscription.save()
domain_obj = Domain.get(domain_obj.get_id)
return (domain_obj, account, subscription)
def setUpClass(cls):
super(BaseCustomerInvoiceCase, cls).setUpClass()
cls.billing_contact = generator.create_arbitrary_web_user_name()
cls.dimagi_user = generator.create_arbitrary_web_user_name(
is_dimagi=True)
cls.account = generator.billing_account(cls.dimagi_user,
cls.billing_contact)
cls.domain = generator.arbitrary_domain()
cls.account.is_customer_billing_account = True
cls.account.save()
cls.advanced_plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED)
cls.advanced_plan.plan.is_customer_software_plan = True
cls.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date,
cls.subscription_length)
cls.subscription = generator.generate_domain_subscription(
cls.account,
cls.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
cls.subscription.plan_version.plan.is_customer_software_plan = True
advanced_subscription_end_date = add_months_to_date(
subscription_end_date, 2)
cls.domain2 = generator.arbitrary_domain()
cls.sub2 = generator.generate_domain_subscription(
cls.account,
cls.domain2,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan)
cls.sub2.plan_version.plan.is_customer_software_plan = True
cls.domain3 = generator.arbitrary_domain()
cls.sub3 = generator.generate_domain_subscription(
cls.account,
cls.domain3,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan)
cls.sub3.plan_version.plan.is_customer_software_plan = True
def test_accounting_future_subscription_suppressed(self):
self.current_subscription.date_end = self.current_subscription.date_start + relativedelta(
days=5)
self.current_subscription.save()
next_subscription = Subscription.new_domain_subscription(
self.current_subscription.account,
self.domain.name,
DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.PRO),
date_start=self.current_subscription.date_end,
)
self.domain.delete()
self.assertTrue(
Subscription.visible_and_suppressed_objects.get(
id=next_subscription.id).is_hidden_to_ops)
def setUpClass(cls):
super(TestDomainsInLineItemForCustomerInvoicing, cls).setUpClass()
cls.customer_account = generator.billing_account('*****@*****.**', '*****@*****.**')
cls.customer_account.is_customer_billing_account = True
cls.customer_account.save()
cls.customer_plan_version = DefaultProductPlan.get_default_plan_version()
cls.customer_plan_version.plan.is_customer_software_plan = True
cls.customer_plan_version.plan.save()
cls.mock_customer_invoice = Mock()
cls.mock_customer_invoice.date_start = date(2019, 5, 1)
cls.mock_customer_invoice.date_end = date(2019, 5, 31)
cls.domain = Domain(name='test_domain')
cls.domain.save()
def prepare_domain(domain_name):
from corehq.apps.commtrack.tests.util import bootstrap_domain
domain = bootstrap_domain(domain_name)
previous = None
for name, administrative in [("MOHSW", True), ("MSDZONE", True),
("REGION", True), ("DISTRICT", True),
("FACILITY", False)]:
previous, _ = LocationType.objects.get_or_create(
domain=domain_name,
name=name,
parent_type=previous,
administrative=administrative,
)
generator.instantiate_accounting()
account = BillingAccount.get_or_create_account_by_domain(
domain.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED)
commtrack = domain.commtrack_settings
commtrack.actions.append(
CommtrackActionConfig(action='receipts',
keyword='delivered',
caption='Delivered'))
commtrack.save()
subscription = Subscription.new_domain_subscription(
account, domain.name, plan)
subscription.is_active = True
subscription.save()
ils_config = ILSGatewayConfig(enabled=True,
domain=domain.name,
all_stock_data=True)
ils_config.save()
fields_definition = CustomDataFieldsDefinition.get_or_create(
domain.name, 'LocationFields')
fields_definition.fields.append(
CustomDataField(slug='group',
label='Group',
is_required=False,
choices=['A', 'B', 'C'],
is_multiple_choice=False))
fields_definition.save()
return domain
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:
logger.error(
"[BILLING] "
"Domain '%s' is going to get charged on "
"Community, but they haven't formally acknowledged this. "
"Someone on ops should reconcile this soon. To be on the "
"safe side, we've marked the invoices as Do Not Invoice."
% self.domain.name
)
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 InvoiceError("No Billing Contact Info could be found "
"for domain '%s'." % 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 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,
entry_point=EntryPoint.SELF_STARTED,
)[0]
if account.date_confirmed_extra_charges is None:
logger.info(
"Did not generate invoice because date_confirmed_extra_charges "
"was null for domain %s" % self.domain.name)
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." % 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 setUpClass(cls):
super(TestZapierCreateCaseAction, cls).setUpClass()
cls.domain_object = Domain.get_or_create_with_name('fruit',
is_active=True)
cls.domain = cls.domain_object.name
account = BillingAccount.get_or_create_account_by_domain(
cls.domain, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.STANDARD)
subscription = Subscription.new_domain_subscription(
account, cls.domain, plan)
subscription.is_active = True
subscription.save()
cls.query_string = "?domain=fruit&case_type=watermelon&owner_id=test_user&user=test"
cls.data = {'case_name': 'test1', 'price': '11'}
cls.user = WebUser.create(cls.domain, 'test', '******', None, None)
api_key_object, _ = HQApiKey.objects.get_or_create(
user=cls.user.get_django_user())
cls.api_key = api_key_object.key
def test_community_over_limit(self):
"""
For a domain under community (no subscription) with users over the community limit, make sure that:
- base_description is None
- base_cost is 0.0
- unit_description is not None
- unit_cost is equal to the per_excess_fee on the user rate
- quantity is equal to number of commcare users in that domain minus the monthly_limit on the user rate
- total and subtotals are equal to number of extra users * per_excess_fee
"""
domain = generator.arbitrary_domain()
self.addCleanup(domain.delete)
num_active = generator.create_excess_community_users(domain)
account = BillingAccount.get_or_create_account_by_domain(
domain, created_by=self.dimagi_user)[0]
generator.arbitrary_contact_info(account, self.dimagi_user)
today = datetime.date.today()
account.date_confirmed_extra_charges = today
account.save()
calculate_users_in_all_domains(
datetime.date(today.year, today.month, 1))
tasks.generate_invoices()
subscriber = Subscriber.objects.get(domain=domain.name)
invoice = Invoice.objects.filter(
subscription__subscriber=subscriber).get()
user_line_item = invoice.lineitem_set.get_feature_by_type(
FeatureType.USER).get()
self.assertIsNone(user_line_item.base_description)
self.assertEqual(user_line_item.base_cost, Decimal('0.0000'))
community_plan = DefaultProductPlan.get_default_plan_version()
num_to_charge = num_active - community_plan.user_limit
self.assertIsNotNone(user_line_item.unit_description)
self.assertEqual(user_line_item.quantity, num_to_charge)
self.assertEqual(user_line_item.unit_cost,
self.user_rate.per_excess_fee)
self.assertEqual(user_line_item.subtotal,
num_to_charge * self.user_rate.per_excess_fee)
self.assertEqual(user_line_item.total,
num_to_charge * self.user_rate.per_excess_fee)
def setUpClass(cls):
super(APIResourceTest, cls).setUpClass()
Role.get_cache().clear()
cls.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
cls.list_endpoint = cls._get_list_endpoint()
cls.username = '******'
cls.password = '******'
cls.user = WebUser.create(cls.domain.name, cls.username, cls.password)
cls.user.set_role(cls.domain.name, 'admin')
cls.user.save()
cls.account = BillingAccount.get_or_create_account_by_domain(cls.domain.name, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
cls.subscription = Subscription.new_domain_subscription(cls.account, cls.domain.name, plan)
cls.subscription.is_active = True
cls.subscription.save()
cls.api_key, _ = ApiKey.objects.get_or_create(user=WebUser.get_django_user(cls.user))
def pause_current_subscription(domain_name, web_user, current_subscription):
from corehq.apps.accounting.models import (
Subscription,
DefaultProductPlan,
SoftwarePlanEdition,
SubscriptionAdjustmentMethod,
SubscriptionType,
ProBonoStatus,
FundingSource,
)
cancel_future_subscriptions(domain_name, datetime.date.today(), web_user)
paused_plan_version = DefaultProductPlan.get_default_plan_version(
SoftwarePlanEdition.PAUSED)
if current_subscription.is_below_minimum_subscription:
current_subscription.update_subscription(
date_start=current_subscription.date_start,
date_end=current_subscription.date_start +
datetime.timedelta(days=30))
return Subscription.new_domain_subscription(
account=current_subscription.account,
domain=domain_name,
plan_version=paused_plan_version,
date_start=current_subscription.date_start +
datetime.timedelta(days=30),
web_user=web_user,
adjustment_method=SubscriptionAdjustmentMethod.USER,
service_type=SubscriptionType.PRODUCT,
pro_bono_status=ProBonoStatus.NO,
funding_source=FundingSource.CLIENT,
do_not_invoice=True,
no_invoice_reason='Paused plan',
)
else:
return current_subscription.change_plan(
paused_plan_version,
web_user=web_user,
adjustment_method=SubscriptionAdjustmentMethod.USER,
service_type=SubscriptionType.PRODUCT,
pro_bono_status=ProBonoStatus.NO,
do_not_invoice=True,
no_invoice_reason='Paused plan',
)
def test_wrong_domain(self):
'''
If correct credentials for a user in a different domain are submitted, the response is forbidden
'''
wrong_domain = Domain.get_or_create_with_name('dvorak', is_active=True)
self.addCleanup(wrong_domain.delete)
# have to set up subscription for the bad domain or it will fail on authorization
new_account = BillingAccount.get_or_create_account_by_domain(wrong_domain.name,
created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
new_subscription = Subscription.new_domain_subscription(new_account, wrong_domain.name, plan)
new_subscription.is_active = True
new_subscription.save()
wrong_list_endpoint = reverse('api_dispatch_list',
kwargs=dict(domain=wrong_domain.name,
api_name=self.api_name,
resource_name=self.resource.Meta.resource_name))
response = self.client.post(wrong_list_endpoint, {'username': self.username, 'password': self.password})
self.assertEqual(response.status_code, 403)
def setUp(self):
super(BaseInvoiceTestCase, self).setUp()
self.billing_contact = generator.arbitrary_web_user()
self.dimagi_user = generator.arbitrary_web_user(is_dimagi=True)
self.currency = generator.init_default_currency()
self.account = generator.billing_account(
self.dimagi_user, self.billing_contact)
self.domain = generator.arbitrary_domain()
self.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
self.community_plan = DefaultProductPlan.get_default_plan_version()
def setUp(self):
super(TestExportUtils, self).setUp()
self.domain = Domain.get_or_create_with_name('test-export-utils',
is_active=True)
self.user = WebUser.create(self.domain.name,
"export-settings-user",
"*******",
None,
None,
is_admin=True)
self.account, _ = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by='*****@*****.**')
self.account.save()
subscription = Subscription.new_domain_subscription(
self.account,
self.domain.name,
DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ENTERPRISE),
date_start=date.today() - timedelta(days=3))
subscription.is_active = True
subscription.save()
def create_30_day_trial(domain_obj):
# 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 setUpClass(cls):
super(TestZapierIntegration, cls).setUpClass()
generator.instantiate_accounting()
cls.domain_object = Domain.get_or_create_with_name(TEST_DOMAIN, is_active=True)
cls.domain = cls.domain_object.name
account = BillingAccount.get_or_create_account_by_domain(cls.domain, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.STANDARD)
subscription = Subscription.new_domain_subscription(account, cls.domain, plan)
subscription.is_active = True
subscription.save()
cls.web_user = WebUser.create(cls.domain, 'test', '******')
api_key_object, _ = ApiKey.objects.get_or_create(user=cls.web_user.get_django_user())
cls.api_key = api_key_object.key
cls.application = Application.new_app(cls.domain, 'Test App')
cls.application.save()
module = cls.application.add_module(Module.new_module("Module 1", "en"))
cls.application.new_form(module.id, name="Form1", attachment=XFORM, lang="en")
cls.application.save()
def setUp(self):
super(TestUserRoleSubscriptionChanges, self).setUp()
self.domain = Domain(
name="test-sub-changes",
is_active=True,
)
self.domain.save()
UserRole.init_domain_with_presets(self.domain.name)
self.user_roles = UserRole.by_domain(self.domain.name)
self.custom_role = UserRole.get_or_create_with_permissions(
self.domain.name, Permissions(edit_apps=True, edit_web_users=True),
"Custom Role")
self.custom_role.save()
self.read_only_role = UserRole.get_read_only_role_by_domain(
self.domain.name)
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.domain.name, is_admin=True)
self.admin_user.save()
self.web_users = []
self.commcare_users = []
for role in [self.custom_role] + self.user_roles:
web_user = generator.arbitrary_web_user()
web_user.add_domain_membership(self.domain.name,
role_id=role.get_id)
web_user.save()
self.web_users.append(web_user)
commcare_user = generator.arbitrary_commcare_user(
domain=self.domain.name)
commcare_user.set_role(self.domain.name, role.get_qualified_id())
commcare_user.save()
self.commcare_users.append(commcare_user)
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.admin_user.username)[0]
self.advanced_plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.ADVANCED)
def _ensure_full_coverage(self, subscriptions):
plan_version = DefaultProductPlan.get_default_plan(
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
# 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.
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__,
entry_point=EntryPoint.SELF_STARTED,
)[0]
if account.date_confirmed_extra_charges is None:
log_accounting_info(
"Did not generate invoice because date_confirmed_extra_charges "
"was null for domain %s" % self.domain.name)
do_not_invoice = True
for start_date, end_date 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=start_date,
date_end=end_date,
do_not_invoice=do_not_invoice,
)
community_subscription.save()
subscriptions.append(community_subscription)
def create_30_day_advanced_trial(domain_obj):
# Create a 30 Day Trial subscription to the Advanced Plan
advanced_plan_version = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED, is_trial=True)
expiration_date = date.today() + timedelta(days=30)
trial_account = BillingAccount.objects.get_or_create(
name=DEFAULT_ACCOUNT_FORMAT % domain_obj.name,
currency=Currency.get_default(),
created_by_domain=domain_obj.name,
account_type=BillingAccountType.USER_CREATED,
pre_or_post_pay=PreOrPostPay.POSTPAY,
)[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,
service_type=SubscriptionType.TRIAL)
trial_subscription.is_active = True
trial_subscription.save()
def test_date_due_not_set_small_invoice(self):
"""Date Due doesn't get set if the invoice is small"""
Subscription.objects.all().delete()
plan_version = DefaultProductPlan.get_default_plan_version(SoftwarePlanEdition.STANDARD)
subscription_length = 5 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, subscription_length)
subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
plan_version=plan_version,
)
invoice_date_small = utils.months_from_date(subscription.date_start, 1)
tasks.generate_invoices(invoice_date_small)
small_invoice = subscription.invoice_set.first()
self.assertTrue(small_invoice.balance <= SMALL_INVOICE_THRESHOLD)
self.assertIsNone(small_invoice.date_due)
def test_date_due_set_large_invoice(self):
"""Date Due only gets set for a large invoice (> $100)"""
Subscription.objects.all().delete()
plan_version = DefaultProductPlan.get_default_plan_version(SoftwarePlanEdition.ADVANCED)
subscription_length = 5 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, subscription_length)
subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
plan_version=plan_version
)
invoice_date_large = utils.months_from_date(subscription.date_start, 3)
tasks.generate_invoices(invoice_date_large)
large_invoice = subscription.invoice_set.last()
self.assertTrue(large_invoice.balance > SMALL_INVOICE_THRESHOLD)
self.assertIsNotNone(large_invoice.date_due)
def wrapped(request, *args, **kwargs):
try:
if (hasattr(request, 'subscription')
and request.subscription is not None and
(request.subscription.is_trial
or request.subscription.plan_version.plan.visibility
== SoftwarePlanVisibility.TRIAL_INTERNAL)
and request.subscription.date_end is not None):
edition_req = DefaultProductPlan.get_lowest_edition_by_domain(
request.domain, [slug])
plan_name = request.subscription.plan_version.user_facing_description[
'name']
feature_name = privileges.Titles.get_name_from_privilege(
slug)
request.show_trial_notice = True
request.trial_info = {
'current_plan':
plan_name,
'feature_name':
feature_name,
'required_plan':
edition_req,
'date_end':
request.subscription.date_end.strftime(
USER_DATE_FORMAT)
}
request.is_domain_admin = (
hasattr(request, 'couch_user')
and request.couch_user.is_domain_admin(request.domain))
return requires_privilege(slug,
**assignment)(fn)(request, *args,
**kwargs)
except PermissionDenied:
request.show_trial_notice = False
from corehq.apps.domain.views import SubscriptionUpgradeRequiredView
return SubscriptionUpgradeRequiredView().get(
request, request.domain, slug)
def response_mobile_worker_creation(domain, new_plan_version):
""" Deactivates users if there are too many for a community plan """
from corehq.apps.accounting.models import (DefaultProductPlan,
FeatureType,
UNLIMITED_FEATURE_USAGE)
# checks for community plan
if (new_plan_version != DefaultProductPlan.get_default_plan_version()):
return True
# checks if unlimited is on for this user
user_rate = new_plan_version.feature_rates.filter(
feature__feature_type=FeatureType.USER).latest('date_created')
if user_rate.monthly_limit == UNLIMITED_FEATURE_USAGE:
return True
# checks for extra users
num_users = CommCareUser.total_by_domain(domain.name, is_active=True)
num_allowed = user_rate.monthly_limit
if num_users > num_allowed:
# offloads deactivation onto a separate thread
bulk_deactivate_users.delay(domain)
return True
