def generate_invoices(based_on_date=None):
"""
Generates all invoices for the past month.
"""
today = based_on_date or datetime.date.today()
invoice_start, invoice_end = get_previous_month_date_range(today)
log_accounting_info(
"Starting up invoices for %(start)s - %(end)s" % {
'start': invoice_start.strftime(USER_DATE_FORMAT),
'end': invoice_end.strftime(USER_DATE_FORMAT),
})
all_domain_ids = [d['id'] for d in Domain.get_all(include_docs=False)]
for domain_doc in iter_docs(Domain.get_db(), all_domain_ids):
domain = Domain.wrap(domain_doc)
try:
invoice_factory = DomainInvoiceFactory(invoice_start, invoice_end,
domain)
invoice_factory.create_invoices()
log_accounting_info("Sent invoices for domain %s" % domain.name)
except CreditLineError as e:
log_accounting_error("There was an error utilizing credits for "
"domain %s: %s" % (domain.name, e))
except InvoiceError as e:
log_accounting_error("Could not create invoice for domain %s: %s" %
(domain.name, e))
except InvoiceAlreadyCreatedError as e:
log_accounting_error("Invoice already existed for domain %s: %s" %
(domain.name, e))
except Exception as e:
log_accounting_error("Error occurred while creating invoice for "
"domain %s: %s" % (domain.name, e))
if not settings.UNIT_TESTING:
_invoicing_complete_soft_assert(False, "Invoicing is complete!")
def generate_invoices(based_on_date=None, check_existing=False, is_test=False):
"""
Generates all invoices for the past month.
"""
today = based_on_date or datetime.date.today()
invoice_start, invoice_end = utils.get_previous_month_date_range(today)
logger.info("[Billing] Starting up invoices for %(start)s - %(end)s" % {
'start': invoice_start.strftime("%d %B %Y"),
'end': invoice_end.strftime("%d %B %Y"),
})
all_domain_ids = [d['id'] for d in Domain.get_all(include_docs=False)]
for domain_doc in iter_docs(Domain.get_db(), all_domain_ids):
domain = Domain.wrap(domain_doc)
if (check_existing and
Invoice.objects.filter(
subscription__subscriber__domain=domain,
date_created__gte=today).count() != 0):
pass
elif is_test:
logger.info("[Billing] Ready to create invoice for domain %s"
% domain.name)
else:
try:
invoice_factory = DomainInvoiceFactory(
invoice_start, invoice_end, domain)
invoice_factory.create_invoices()
logger.info("[BILLING] Sent invoices for domain %s"
% domain.name)
except CreditLineError as e:
logger.error(
"[BILLING] There was an error utilizing credits for "
"domain %s: %s" % (domain.name, e)
)
except BillingContactInfoError as e:
subject = "[%s] Invoice Generation Issue" % domain.name
email_content = render_to_string(
'accounting/invoice_error_email.html', {
'project': domain.name,
'error_msg': 'BillingContactInfoError: %s' % e,
}
)
send_HTML_email(
subject, settings.BILLING_EMAIL, email_content,
email_from="Dimagi Billing Bot <%s>" % settings.DEFAULT_FROM_EMAIL
)
except InvoiceError as e:
logger.error(
"[BILLING] Could not create invoice for domain %s: %s" % (
domain.name, e
))
except Exception as e:
logger.error(
"[BILLING] Error occurred while creating invoice for "
"domain %s: %s" % (domain.name, e)
)
# And finally...
if not is_test:
send_bookkeeper_email()
def generate_invoices(based_on_date=None, check_existing=False, is_test=False):
"""
Generates all invoices for the past month.
"""
today = based_on_date or datetime.date.today()
invoice_start, invoice_end = utils.get_previous_month_date_range(today)
logger.info(
"[Billing] Starting up invoices for %(start)s - %(end)s" % {
'start': invoice_start.strftime("%d %B %Y"),
'end': invoice_end.strftime("%d %B %Y"),
})
all_domain_ids = [d['id'] for d in Domain.get_all(include_docs=False)]
for domain_doc in iter_docs(Domain.get_db(), all_domain_ids):
domain = Domain.wrap(domain_doc)
if (check_existing and
Invoice.objects.filter(subscription__subscriber__domain=domain,
date_created__gte=today).count() != 0):
pass
elif is_test:
logger.info("[Billing] Ready to create invoice for domain %s" %
domain.name)
else:
try:
invoice_factory = DomainInvoiceFactory(invoice_start,
invoice_end, domain)
invoice_factory.create_invoices()
logger.info("[BILLING] Sent invoices for domain %s" %
domain.name)
except CreditLineError as e:
logger.error(
"[BILLING] There was an error utilizing credits for "
"domain %s: %s" % (domain.name, e))
except BillingContactInfoError as e:
subject = "[%s] Invoice Generation Issue" % domain.name
email_content = render_to_string(
'accounting/invoice_error_email.html', {
'project': domain.name,
'error_msg': 'BillingContactInfoError: %s' % e,
})
send_HTML_email(subject,
settings.BILLING_EMAIL,
email_content,
email_from="Dimagi Billing Bot <%s>" %
settings.DEFAULT_FROM_EMAIL)
except InvoiceError as e:
logger.error(
"[BILLING] Could not create invoice for domain %s: %s" %
(domain.name, e))
except Exception as e:
logger.error(
"[BILLING] Error occurred while creating invoice for "
"domain %s: %s" % (domain.name, e))
# And finally...
if not is_test:
send_bookkeeper_email()
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 generate_invoices(based_on_date=None, check_existing=False, is_test=False):
"""
Generates all invoices for the past month.
"""
today = based_on_date or datetime.date.today()
invoice_start, invoice_end = utils.get_previous_month_date_range(today)
logger.info("[Billing] Starting up invoices for %(start)s - %(end)s" % {
'start': invoice_start.strftime(USER_DATE_FORMAT),
'end': invoice_end.strftime(USER_DATE_FORMAT),
})
all_domain_ids = [d['id'] for d in Domain.get_all(include_docs=False)]
for domain_doc in iter_docs(Domain.get_db(), all_domain_ids):
domain = Domain.wrap(domain_doc)
if (check_existing and
Invoice.objects.filter(
subscription__subscriber__domain=domain,
date_created__gte=today).count() != 0):
pass
elif is_test:
logger.info("[Billing] Ready to create invoice for domain %s"
% domain.name)
else:
try:
invoice_factory = DomainInvoiceFactory(
invoice_start, invoice_end, domain)
invoice_factory.create_invoices()
logger.info("[BILLING] Sent invoices for domain %s"
% domain.name)
except CreditLineError as e:
logger.error(
"[BILLING] There was an error utilizing credits for "
"domain %s: %s" % (domain.name, e)
)
except BillingContactInfoError as e:
logger.info("BillingContactInfoError: %s" % e)
except InvoiceError as e:
logger.error(
"[BILLING] Could not create invoice for domain %s: %s" % (
domain.name, e
))
except InvoiceAlreadyCreatedError as e:
logger.error(
"[BILLING] Invoice already existed for domain %s: %s" % (
domain.name, e
))
except Exception as e:
logger.error(
"[BILLING] Error occurred while creating invoice for "
"domain %s: %s" % (domain.name, e)
)
def generate_invoices(based_on_date=None):
"""
Generates all invoices for the past month.
"""
today = based_on_date or datetime.date.today()
invoice_start, invoice_end = get_previous_month_date_range(today)
log_accounting_info("Starting up invoices for %(start)s - %(end)s" % {
'start': invoice_start.strftime(USER_DATE_FORMAT),
'end': invoice_end.strftime(USER_DATE_FORMAT),
})
all_domain_ids = [d['id'] for d in Domain.get_all(include_docs=False)]
for domain_doc in iter_docs(Domain.get_db(), all_domain_ids):
domain = Domain.wrap(domain_doc)
try:
invoice_factory = DomainInvoiceFactory(
invoice_start, invoice_end, domain)
invoice_factory.create_invoices()
log_accounting_info("Sent invoices for domain %s" % domain.name)
except CreditLineError as e:
log_accounting_error(
"There was an error utilizing credits for "
"domain %s: %s" % (domain.name, e)
)
except InvoiceError as e:
log_accounting_error(
"Could not create invoice for domain %s: %s" % (domain.name, e)
)
except InvoiceAlreadyCreatedError as e:
log_accounting_error(
"Invoice already existed for domain %s: %s" % (domain.name, e)
)
except Exception as e:
log_accounting_error(
"Error occurred while creating invoice for "
"domain %s: %s" % (domain.name, e)
)
if not settings.UNIT_TESTING:
_invoicing_complete_soft_assert(False, "Invoicing is complete!")
def _test_specified_recipients(self):
DomainInvoiceFactory(
self.subscription.date_start,
utils.months_from_date(self.subscription.date_start, 1) -
datetime.timedelta(days=1),
self.subscription.subscriber.domain,
recipients=['*****@*****.**',
'*****@*****.**']).create_invoices()
self.assertEqual(len(mail.outbox), 2)
self.assertListEqual(mail.outbox[0].to, ['*****@*****.**'])
self.assertListEqual(mail.outbox[0].cc, [])
self.assertListEqual(mail.outbox[1].to, ['*****@*****.**'])
self.assertListEqual(mail.outbox[1].cc, [])
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().plan.get_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
)
class TestDomainInvoiceFactory(BaseAccountingTest):
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_by_domain(
self.domain).plan.get_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 _clean_subs(self):
SubscriptionAdjustment.objects.all().delete()
Subscription.objects.all().delete()
def test_feature_charges(self):
domain_under_limits = generator.arbitrary_domain()
self.assertTrue(
self.community.feature_charges_exist_for_domain(self.domain))
self.assertFalse(
self.community.feature_charges_exist_for_domain(
domain_under_limits))
def test_incomplete_starting_coverage(self):
some_plan = generator.arbitrary_subscribable_plan()
subscription = Subscription.new_domain_subscription(
self.account,
self.domain,
some_plan,
date_start=self.invoice_start + datetime.timedelta(days=3))
subscriptions = self.invoice_factory.get_subscriptions()
community_ranges = self.invoice_factory.get_community_ranges(
subscriptions)
self.assertEqual(len(community_ranges), 1)
self.assertEqual(community_ranges[0][0], self.invoice_start)
self.assertEqual(community_ranges[0][1], subscription.date_start)
self._clean_subs()
def test_incomplete_ending_coverage(self):
some_plan = generator.arbitrary_subscribable_plan()
subscription = Subscription.new_domain_subscription(
self.account,
self.domain,
some_plan,
date_start=self.invoice_start,
date_end=self.invoice_end - datetime.timedelta(days=3))
subscriptions = self.invoice_factory.get_subscriptions()
community_ranges = self.invoice_factory.get_community_ranges(
subscriptions)
self.assertEqual(len(community_ranges), 1)
self.assertEqual(community_ranges[0][0], subscription.date_end)
self.assertEqual(community_ranges[0][1],
self.invoice_end + datetime.timedelta(days=1))
self._clean_subs()
def test_patchy_coverage(self):
some_plan = generator.arbitrary_subscribable_plan()
middle_date = self.invoice_end - datetime.timedelta(days=15)
Subscription.new_domain_subscription(self.account,
self.domain,
some_plan,
date_start=self.invoice_start +
datetime.timedelta(days=1),
date_end=middle_date)
next_start = middle_date + datetime.timedelta(days=2)
next_end = next_start + datetime.timedelta(days=2)
Subscription.new_domain_subscription(
self.account,
self.domain,
some_plan,
date_start=next_start,
date_end=next_end,
)
final_start = next_end + datetime.timedelta(days=2)
Subscription.new_domain_subscription(
self.account,
self.domain,
some_plan,
date_start=final_start,
date_end=self.invoice_end - datetime.timedelta(days=1),
)
subscriptions = self.invoice_factory.get_subscriptions()
self.assertEqual(len(subscriptions), 3)
community_ranges = self.invoice_factory.get_community_ranges(
subscriptions)
self.assertEqual(len(community_ranges), 4)
self._clean_subs()
def test_full_coverage(self):
some_plan = generator.arbitrary_subscribable_plan()
Subscription.new_domain_subscription(
self.account,
self.domain,
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)
self._clean_subs()
def test_no_coverage(self):
subscriptions = self.invoice_factory.get_subscriptions()
self.assertEqual(len(subscriptions), 0)
community_ranges = self.invoice_factory.get_community_ranges(
subscriptions)
self.assertEqual(len(community_ranges), 1)
class TestDomainInvoiceFactory(BaseAccountingTest):
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_by_domain(
self.domain).plan.get_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 _clean_subs(self):
SubscriptionAdjustment.objects.all().delete()
Subscription.objects.all().delete()
def test_feature_charges(self):
domain_under_limits = generator.arbitrary_domain()
self.assertTrue(self.community.feature_charges_exist_for_domain(self.domain))
self.assertFalse(self.community.feature_charges_exist_for_domain(domain_under_limits))
def test_incomplete_starting_coverage(self):
some_plan = generator.arbitrary_subscribable_plan()
subscription = Subscription.new_domain_subscription(
self.account, self.domain, some_plan,
date_start=self.invoice_start + datetime.timedelta(days=3)
)
subscriptions = self.invoice_factory.get_subscriptions()
community_ranges = self.invoice_factory.get_community_ranges(subscriptions)
self.assertEqual(len(community_ranges), 1)
self.assertEqual(community_ranges[0][0], self.invoice_start)
self.assertEqual(community_ranges[0][1], subscription.date_start)
self._clean_subs()
def test_incomplete_ending_coverage(self):
some_plan = generator.arbitrary_subscribable_plan()
subscription = Subscription.new_domain_subscription(
self.account, self.domain, some_plan,
date_start=self.invoice_start,
date_end=self.invoice_end - datetime.timedelta(days=3)
)
subscriptions = self.invoice_factory.get_subscriptions()
community_ranges = self.invoice_factory.get_community_ranges(subscriptions)
self.assertEqual(len(community_ranges), 1)
self.assertEqual(community_ranges[0][0], subscription.date_end)
self.assertEqual(community_ranges[0][1],
self.invoice_end + datetime.timedelta(days=1))
self._clean_subs()
def test_patchy_coverage(self):
some_plan = generator.arbitrary_subscribable_plan()
middle_date = self.invoice_end - datetime.timedelta(days=15)
Subscription.new_domain_subscription(
self.account, self.domain, some_plan,
date_start=self.invoice_start + datetime.timedelta(days=1),
date_end=middle_date
)
next_start = middle_date + datetime.timedelta(days=2)
next_end = next_start + datetime.timedelta(days=2)
Subscription.new_domain_subscription(
self.account, self.domain, some_plan,
date_start=next_start,
date_end=next_end,
)
final_start = next_end + datetime.timedelta(days=2)
Subscription.new_domain_subscription(
self.account, self.domain, some_plan,
date_start=final_start,
date_end=self.invoice_end - datetime.timedelta(days=1),
)
subscriptions = self.invoice_factory.get_subscriptions()
self.assertEqual(len(subscriptions), 3)
community_ranges = self.invoice_factory.get_community_ranges(subscriptions)
self.assertEqual(len(community_ranges), 4)
self._clean_subs()
def test_full_coverage(self):
some_plan = generator.arbitrary_subscribable_plan()
Subscription.new_domain_subscription(
self.account, self.domain, 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)
self._clean_subs()
def test_no_coverage(self):
subscriptions = self.invoice_factory.get_subscriptions()
self.assertEqual(len(subscriptions), 0)
community_ranges = self.invoice_factory.get_community_ranges(subscriptions)
self.assertEqual(len(community_ranges), 1)
def generate_invoices(based_on_date=None):
"""
Generates all invoices for the past month.
"""
today = based_on_date or datetime.date.today()
invoice_start, invoice_end = get_previous_month_date_range(today)
log_accounting_info(
"Starting up invoices for %(start)s - %(end)s" % {
'start': invoice_start.strftime(USER_DATE_FORMAT),
'end': invoice_end.strftime(USER_DATE_FORMAT),
})
all_domain_ids = [d['id'] for d in Domain.get_all(include_docs=False)]
for domain_doc in iter_docs(Domain.get_db(), all_domain_ids):
domain_obj = Domain.wrap(domain_doc)
if not domain_obj.is_active:
continue
try:
invoice_factory = DomainInvoiceFactory(invoice_start, invoice_end,
domain_obj)
invoice_factory.create_invoices()
log_accounting_info("Sent invoices for domain %s" %
domain_obj.name)
except CreditLineError as e:
log_accounting_error(
"There was an error utilizing credits for "
"domain %s: %s" % (domain_obj.name, e),
show_stack_trace=True,
)
except InvoiceError as e:
log_accounting_error(
"Could not create invoice for domain %s: %s" %
(domain_obj.name, e),
show_stack_trace=True,
)
except Exception as e:
log_accounting_error(
"Error occurred while creating invoice for "
"domain %s: %s" % (domain_obj.name, e),
show_stack_trace=True,
)
all_customer_billing_accounts = BillingAccount.objects.filter(
is_customer_billing_account=True)
for account in all_customer_billing_accounts:
try:
if account.invoicing_plan == InvoicingPlan.QUARTERLY:
customer_invoice_start = invoice_start - relativedelta(
months=2)
elif account.invoicing_plan == InvoicingPlan.YEARLY:
customer_invoice_start = invoice_start - relativedelta(
months=11)
else:
customer_invoice_start = invoice_start
invoice_factory = CustomerAccountInvoiceFactory(
account=account,
date_start=customer_invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
except CreditLineError as e:
log_accounting_error(
"There was an error utilizing credits for "
"domain %s: %s" % (domain_obj.name, e),
show_stack_trace=True,
)
except InvoiceError as e:
log_accounting_error(
"Could not create invoice for domain %s: %s" %
(domain_obj.name, e),
show_stack_trace=True,
)
except Exception as e:
log_accounting_error(
"Error occurred while creating invoice for "
"domain %s: %s" % (domain_obj.name, e),
show_stack_trace=True,
)
if not settings.UNIT_TESTING:
_invoicing_complete_soft_assert(False, "Invoicing is complete!")
class TestDomainInvoiceFactory(BaseAccountingTest):
@classmethod
def setUpClass(cls):
super(TestDomainInvoiceFactory, cls).setUpClass()
generator.bootstrap_test_software_plan_versions()
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 tearDown(self):
self.domain.delete()
super(TestDomainInvoiceFactory, self).tearDown()
@classmethod
def tearDownClass(cls):
clear_plan_version_cache()
super(TestDomainInvoiceFactory, cls).tearDownClass()
def test_feature_charges(self):
domain_under_limits = generator.arbitrary_domain()
self.assertTrue(
self.community.feature_charges_exist_for_domain(self.domain))
self.assertFalse(
self.community.feature_charges_exist_for_domain(
domain_under_limits))
domain_under_limits.delete()
def test_incomplete_starting_coverage(self):
some_plan = generator.subscribable_plan_version()
subscription = Subscription.new_domain_subscription(
self.account,
self.domain.name,
some_plan,
date_start=self.invoice_start + datetime.timedelta(days=3))
subscriptions = self.invoice_factory._get_subscriptions()
community_ranges = self.invoice_factory._get_community_ranges(
subscriptions)
self.assertEqual(len(community_ranges), 1)
self.assertEqual(community_ranges[0][0], self.invoice_start)
self.assertEqual(community_ranges[0][1], subscription.date_start)
def test_incomplete_ending_coverage(self):
some_plan = generator.subscribable_plan_version()
subscription = Subscription.new_domain_subscription(
self.account,
self.domain.name,
some_plan,
date_start=self.invoice_start,
date_end=self.invoice_end - datetime.timedelta(days=3))
subscriptions = self.invoice_factory._get_subscriptions()
community_ranges = self.invoice_factory._get_community_ranges(
subscriptions)
self.assertEqual(len(community_ranges), 1)
self.assertEqual(community_ranges[0][0], subscription.date_end)
self.assertEqual(community_ranges[0][1],
self.invoice_end + datetime.timedelta(days=1))
def test_patchy_coverage(self):
some_plan = generator.subscribable_plan_version()
middle_date = self.invoice_end - datetime.timedelta(days=15)
Subscription.new_domain_subscription(self.account,
self.domain.name,
some_plan,
date_start=self.invoice_start +
datetime.timedelta(days=1),
date_end=middle_date)
next_start = middle_date + datetime.timedelta(days=2)
next_end = next_start + datetime.timedelta(days=2)
Subscription.new_domain_subscription(
self.account,
self.domain.name,
some_plan,
date_start=next_start,
date_end=next_end,
)
final_start = next_end + datetime.timedelta(days=2)
Subscription.new_domain_subscription(
self.account,
self.domain.name,
some_plan,
date_start=final_start,
date_end=self.invoice_end - datetime.timedelta(days=1),
)
subscriptions = self.invoice_factory._get_subscriptions()
self.assertEqual(len(subscriptions), 3)
community_ranges = self.invoice_factory._get_community_ranges(
subscriptions)
self.assertEqual(len(community_ranges), 4)
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_no_coverage(self):
subscriptions = self.invoice_factory._get_subscriptions()
self.assertEqual(len(subscriptions), 0)
community_ranges = self.invoice_factory._get_community_ranges(
subscriptions)
self.assertEqual(community_ranges, [
(self.invoice_start, self.invoice_end + datetime.timedelta(days=1))
])
def test_paused_plan_generates_no_invoice(self):
"""
Ensure that paused plans do not generate invoices.
"""
paused_plan = generator.subscribable_plan_version(
edition=SoftwarePlanEdition.PAUSED)
Subscription.new_domain_subscription(
self.account,
self.domain.name,
paused_plan,
date_start=self.invoice_start,
date_end=self.invoice_end + datetime.timedelta(days=1),
)
self.assertListEqual(self.invoice_factory._get_subscriptions(), [])
def generate_invoices(based_on_date=None):
"""
Generates all invoices for the past month.
"""
today = based_on_date or datetime.date.today()
invoice_start, invoice_end = get_previous_month_date_range(today)
log_accounting_info("Starting up invoices for %(start)s - %(end)s" % {
'start': invoice_start.strftime(USER_DATE_FORMAT),
'end': invoice_end.strftime(USER_DATE_FORMAT),
})
all_domain_ids = [d['id'] for d in Domain.get_all(include_docs=False)]
for domain_doc in iter_docs(Domain.get_db(), all_domain_ids):
domain_obj = Domain.wrap(domain_doc)
if not domain_obj.is_active:
continue
try:
invoice_factory = DomainInvoiceFactory(invoice_start, invoice_end, domain_obj)
invoice_factory.create_invoices()
log_accounting_info("Sent invoices for domain %s" % domain_obj.name)
except CreditLineError as e:
log_accounting_error(
"There was an error utilizing credits for "
"domain %s: %s" % (domain_obj.name, e),
show_stack_trace=True,
)
except InvoiceError as e:
log_accounting_error(
"Could not create invoice for domain %s: %s" % (domain_obj.name, e),
show_stack_trace=True,
)
except Exception as e:
log_accounting_error(
"Error occurred while creating invoice for "
"domain %s: %s" % (domain_obj.name, e),
show_stack_trace=True,
)
all_customer_billing_accounts = BillingAccount.objects.filter(is_customer_billing_account=True)
for account in all_customer_billing_accounts:
try:
if account.invoicing_plan == InvoicingPlan.QUARTERLY:
customer_invoice_start = invoice_start - relativedelta(months=2)
elif account.invoicing_plan == InvoicingPlan.YEARLY:
customer_invoice_start = invoice_start - relativedelta(months=11)
else:
customer_invoice_start = invoice_start
invoice_factory = CustomerAccountInvoiceFactory(
account=account,
date_start=customer_invoice_start,
date_end=invoice_end
)
invoice_factory.create_invoice()
except CreditLineError as e:
log_accounting_error(
"There was an error utilizing credits for "
"domain %s: %s" % (domain_obj.name, e),
show_stack_trace=True,
)
except InvoiceError as e:
log_accounting_error(
"Could not create invoice for domain %s: %s" % (domain_obj.name, e),
show_stack_trace=True,
)
except Exception as e:
log_accounting_error(
"Error occurred while creating invoice for "
"domain %s: %s" % (domain_obj.name, e),
show_stack_trace=True,
)
if not settings.UNIT_TESTING:
_invoicing_complete_soft_assert(False, "Invoicing is complete!")
