def setUp(self):
super(TestBillingRecord, self).setUp()
self.billing_contact = generator.create_arbitrary_web_user_name()
self.dimagi_user = generator.create_arbitrary_web_user_name(
is_dimagi=True)
self.domain = Domain(name='test')
self.domain.save()
self.invoice_start, self.invoice_end = get_previous_month_date_range()
self.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user,
self.billing_contact)
self.subscription_length = 4 # 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.invoice = Invoice(
subscription=self.subscription,
date_start=self.invoice_start,
date_end=self.invoice_end,
is_hidden=False,
)
self.billing_record = BillingRecord(invoice=self.invoice)
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_multiple_subscription_invoice(self):
invoice_date = utils.months_from_date(
self.subscription.date_start,
random.randint(2, self.subscription_length))
invoice_start, invoice_end = get_previous_month_date_range(
invoice_date)
invoice_factory = CustomerAccountInvoiceFactory(
account=self.account,
date_start=invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertGreater(invoice.balance, Decimal('0.0000'))
self.assertEqual(invoice.account, self.account)
num_product_line_items = invoice.lineitem_set.get_products().count()
self.assertEqual(num_product_line_items, 2)
num_feature_line_items = invoice.lineitem_set.get_features().count()
self.assertEqual(
num_feature_line_items,
self.subscription.plan_version.feature_rates.count() +
self.sub2.plan_version.feature_rates.count())
def setUp(self):
super(TestBillingRecord, self).setUp()
self.billing_contact = generator.arbitrary_web_user()
self.dimagi_user = generator.arbitrary_web_user(is_dimagi=True)
self.domain = Domain(name='test')
self.domain.save()
self.invoice_start, self.invoice_end = get_previous_month_date_range()
self.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user, self.billing_contact)
self.subscription_length = 4 # 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.invoice = Invoice(
subscription=self.subscription,
date_start=self.invoice_start,
date_end=self.invoice_end,
is_hidden=False,
)
self.billing_record = BillingRecord(invoice=self.invoice)
def all_month_ends_in_invoice(self):
_, month_end = get_first_last_days(self.invoice.date_end.year, self.invoice.date_end.month)
dates = []
while month_end > self.invoice.date_start:
dates.append(month_end)
_, month_end = get_previous_month_date_range(month_end)
return dates
def run(cls, row_num, raw_row, fields_to_update, import_context):
error_messages = []
if raw_row.get(SKIP_CALL_VALIDATOR):
# skip the row
# add error message if the value isn't the only expected value
if raw_row.get(SKIP_CALL_VALIDATOR) != SKIP_CALL_VALIDATOR_YES:
error_messages.append(UnexpectedSkipCallValidatorValueError())
return fields_to_update, error_messages
call_date = None
call_value, call_number = _get_latest_call_value_and_number(
fields_to_update)
if not call_value:
error_messages.append(CallValuesMissingError())
else:
try:
call_date = iso_string_to_date(call_value)
except ValueError:
error_messages.append(CallValueInvalidError())
if call_date:
last_month_first_day, last_month_last_day = get_previous_month_date_range(
datetime.date.today())
if call_date.replace(day=1) != last_month_first_day:
error_messages.append(CallNotInLastMonthError())
return fields_to_update, error_messages
def test_only_invoice_active_subscriptions(self):
"""
Test that only active subscriptions are invoiced.
Two subscriptions of the same plan only create one product line item and one set of feature line items
"""
invoice_date = utils.months_from_date(self.sub2.date_end, 1)
invoice_start, invoice_end = get_previous_month_date_range(
invoice_date)
invoice_factory = CustomerAccountInvoiceFactory(
account=self.account,
date_start=invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertEqual(invoice.balance, Decimal('1000.0000'))
self.assertEqual(invoice.account, self.account)
num_product_line_items = invoice.lineitem_set.get_products().count()
self.assertEqual(num_product_line_items, 1)
num_feature_line_items = invoice.lineitem_set.get_features().count()
self.assertEqual(num_feature_line_items,
self.sub2.plan_version.feature_rates.count())
def test_product_line_items(self):
invoice_date = utils.months_from_date(
self.subscription.date_start,
random.randint(2, self.subscription_length))
invoice_start, invoice_end = get_previous_month_date_range(
invoice_date)
invoice_factory = CustomerAccountInvoiceFactory(
account=self.account,
date_start=invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
product_line_items = invoice.lineitem_set.get_products()
self.assertEqual(product_line_items.count(), 2)
for line_item in product_line_items:
self.assertTrue(line_item.base_description
== 'One month of CommCare Advanced Software Plan.'
or line_item.base_description
== 'One month of CommCare Standard Software Plan.')
self.assertTrue(
line_item.base_cost == self.product_rate.monthly_fee
or line_item.base_cost
== self.advanced_plan.product_rate.monthly_fee)
def test_user_over_limit_in_yearly_invoice(self):
num_users = self.user_rate.monthly_limit + 1
generator.arbitrary_commcare_users_for_domain(self.domain.name,
num_users)
num_users_advanced = self.advanced_rate.monthly_limit + 2
generator.arbitrary_commcare_users_for_domain(self.domain2.name,
num_users_advanced)
self.account.invoicing_plan = InvoicingPlan.YEARLY
self.account.save()
invoice_date = utils.months_from_date(self.subscription.date_start, 14)
invoice_start, invoice_end = get_previous_month_date_range(
invoice_date)
invoice_start = invoice_start - relativedelta(months=11)
invoice_factory = CustomerAccountInvoiceFactory(
account=self.account,
date_start=invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
user_line_items = invoice.lineitem_set.get_feature_by_type(
FeatureType.USER)
self.assertEqual(user_line_items.count(), 2)
for user_line_item in user_line_items:
if self.user_rate.feature.name == user_line_item.feature_rate.feature.name:
self.assertEqual(user_line_item.quantity, 12)
elif user_line_item.feature_rate.feature.name == self.advanced_rate.feature.name:
self.assertEqual(user_line_item.quantity, 24)
def initialize_domain_user_history_objects(self):
record_dates = []
month_end = self.subscription.date_end
while month_end > self.subscription.date_start:
record_dates.append(month_end)
_, month_end = get_previous_month_date_range(month_end)
num_users = self.user_rate.monthly_limit + 1
for record_date in record_dates:
DomainUserHistory.objects.create(
domain=self.domain,
num_users=num_users,
record_date=record_date
)
num_users = self.advanced_rate.monthly_limit + 2
for record_date in record_dates:
DomainUserHistory.objects.create(
domain=self.domain2,
num_users=num_users,
record_date=record_date
)
for record_date in record_dates:
DomainUserHistory.objects.create(
domain=self.domain3,
num_users=0,
record_date=record_date
)
def all_month_ends_in_invoice(self):
month_end = self.invoice.date_end
dates = []
while month_end > self.invoice.date_start:
dates.append(month_end)
_, month_end = get_previous_month_date_range(month_end)
return dates
def get_daterange_start_end_dates(date_range, start_date=None, end_date=None, days=None):
today = datetime.date.today()
if date_range == 'since':
start_date = start_date
end_date = today
elif date_range == 'range':
start_date = start_date
end_date = end_date
elif date_range == 'thismonth':
start_date, end_date = get_current_month_date_range()
elif date_range == 'lastmonth':
start_date, end_date = get_previous_month_date_range()
elif date_range == 'lastyear':
last_year = today.year - 1
return datetime.date(last_year, 1, 1), datetime.date(last_year, 12, 31)
else:
end_date = today
days = {
'last7': 7,
'last30': 30,
'lastn': days
}.get(date_range)
if days is None:
raise InvalidDaterangeException
start_date = today - datetime.timedelta(days=days)
if start_date is None or end_date is None:
raise InvalidDaterangeException
return start_date, end_date
def all_month_ends_in_invoice(self):
month_end = self.invoice.date_end
dates = []
while month_end > self.invoice.date_start:
dates.append(month_end)
_, month_end = get_previous_month_date_range(month_end)
return dates
def test_under_limit(self):
num_users = random.randint(0, self.user_rate.monthly_limit)
generator.arbitrary_commcare_users_for_domain(self.domain.name,
num_users)
num_users_advanced = random.randint(0,
self.advanced_rate.monthly_limit)
generator.arbitrary_commcare_users_for_domain(self.domain2.name,
num_users_advanced)
invoice_date = utils.months_from_date(
self.subscription.date_start,
random.randint(2, self.subscription_length))
invoice_start, invoice_end = get_previous_month_date_range(
invoice_date)
invoice_factory = CustomerAccountInvoiceFactory(
account=self.account,
date_start=invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertEqual(invoice.balance, Decimal('1100.0000'))
user_line_items = invoice.lineitem_set.get_feature_by_type(
FeatureType.USER)
self.assertEqual(user_line_items.count(), 2)
for user_line_item in user_line_items:
self.assertEqual(user_line_item.quantity, 0)
self.assertEqual(user_line_item.subtotal, Decimal('0.0000'))
self.assertEqual(user_line_item.total, Decimal('0.0000'))
self.assertIsNone(user_line_item.base_description)
self.assertEqual(user_line_item.base_cost, Decimal('0.0000'))
self.assertIsNone(user_line_item.unit_description)
self.assertEqual(user_line_item.unit_cost, Decimal('2.0000'))
def send_bookkeeper_email(month=None, year=None, emails=None):
today = datetime.date.today()
# now, make sure that we send out LAST month's invoices if we did
# not specify a month or year.
today = get_previous_month_date_range(today)[0]
month = month or today.month
year = year or today.year
from corehq.apps.accounting.interface import InvoiceInterface
request = HttpRequest()
params = urlencode((
('report_filter_statement_period_use_filter', 'on'),
('report_filter_statement_period_month', month),
('report_filter_statement_period_year', year),
))
request.GET = QueryDict(params)
request.couch_user = FakeUser(
domain="hqadmin",
username="******",
)
invoice = InvoiceInterface(request)
invoice.is_rendered_as_email = True
first_of_month = datetime.date(year, month, 1)
email_context = {
'month': first_of_month.strftime("%B"),
}
email_content = render_to_string(
'accounting/email/bookkeeper.html', email_context)
email_content_plaintext = render_to_string(
'accounting/email/bookkeeper.txt', email_context)
format_dict = Format.FORMAT_DICT[Format.CSV]
excel_attachment = {
'title': 'Invoices_%(period)s.%(extension)s' % {
'period': first_of_month.strftime('%B_%Y'),
'extension': format_dict['extension'],
},
'mimetype': format_dict['mimetype'],
'file_obj': invoice.excel_response,
}
emails = emails or settings.BOOKKEEPER_CONTACT_EMAILS
for email in emails:
send_HTML_email(
"Invoices for %s" % datetime.date(year, month, 1).strftime(USER_MONTH_FORMAT),
email,
email_content,
email_from=settings.DEFAULT_FROM_EMAIL,
text_content=email_content_plaintext,
file_attachments=[excel_attachment],
)
log_accounting_info(
"Sent Bookkeeper Invoice Summary for %(month)s "
"to %(emails)s." % {
'month': first_of_month.strftime(USER_MONTH_FORMAT),
'emails': ", ".join(emails)
})
def send_bookkeeper_email(month=None, year=None, emails=None):
today = datetime.date.today()
# now, make sure that we send out LAST month's invoices if we did
# not specify a month or year.
today = get_previous_month_date_range(today)[0]
month = month or today.month
year = year or today.year
from corehq.apps.accounting.interface import InvoiceInterface
request = HttpRequest()
params = urlencode((
('report_filter_statement_period_use_filter', 'on'),
('report_filter_statement_period_month', month),
('report_filter_statement_period_year', year),
))
request.GET = QueryDict(params)
request.couch_user = FakeUser(
domain="hqadmin",
username="******",
)
invoice = InvoiceInterface(request)
invoice.is_rendered_as_email = True
first_of_month = datetime.date(year, month, 1)
email_context = {
'month': first_of_month.strftime("%B"),
}
email_content = render_to_string(
'accounting/bookkeeper_email.html', email_context)
email_content_plaintext = render_to_string(
'accounting/bookkeeper_email_plaintext.html', email_context)
format_dict = Format.FORMAT_DICT[Format.CSV]
excel_attachment = {
'title': 'Invoices_%(period)s.%(extension)s' % {
'period': first_of_month.strftime('%B_%Y'),
'extension': format_dict['extension'],
},
'mimetype': format_dict['mimetype'],
'file_obj': invoice.excel_response,
}
emails = emails or settings.BOOKKEEPER_CONTACT_EMAILS
for email in emails:
send_HTML_email(
"Invoices for %s" % datetime.date(year, month, 1).strftime(USER_MONTH_FORMAT),
email,
email_content,
email_from=settings.DEFAULT_FROM_EMAIL,
text_content=email_content_plaintext,
file_attachments=[excel_attachment],
)
log_accounting_info(
"Sent Bookkeeper Invoice Summary for %(month)s "
"to %(emails)s." % {
'month': first_of_month.strftime(USER_MONTH_FORMAT),
'emails': ", ".join(emails)
})
def _create_sms_line_items_for_quarter(self):
invoice_start, invoice_end = get_previous_month_date_range(
self.invoice_date)
invoice_factory = CustomerAccountInvoiceFactory(
account=self.account,
date_start=invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
return invoice.lineitem_set.get_feature_by_type(FeatureType.SMS)
def test_no_invoice_before_start(self):
"""
Test that an invoice is not created if its subscriptions didn't start in the previous month.
"""
invoice_start, invoice_end = get_previous_month_date_range(
self.subscription.date_start)
invoice_factory = CustomerAccountInvoiceFactory(
account=self.account,
date_start=invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
self.assertEqual(CustomerInvoice.objects.count(), 0)
def test_no_invoice_after_end(self):
"""
No invoices should be generated for the months after the end date of the subscriptions.
"""
invoice_date = utils.months_from_date(self.sub2.date_end, 2)
invoice_start, invoice_end = get_previous_month_date_range(
invoice_date)
invoice_factory = CustomerAccountInvoiceFactory(
account=self.account,
date_start=invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
self.assertEqual(CustomerInvoice.objects.count(), 0)
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 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
)
def test_over_limit(self):
num_users = self.user_rate.monthly_limit + 1
generator.arbitrary_commcare_users_for_domain(self.domain.name,
num_users)
num_users_advanced = self.advanced_rate.monthly_limit + 1
generator.arbitrary_commcare_users_for_domain(self.domain2.name,
num_users_advanced)
invoice_date = utils.months_from_date(
self.subscription.date_start,
random.randint(2, self.subscription_length))
invoice_start, invoice_end = get_previous_month_date_range(
invoice_date)
invoice_factory = CustomerAccountInvoiceFactory(
account=self.account,
date_start=invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
user_line_items = invoice.lineitem_set.get_feature_by_type(
FeatureType.USER)
self.assertEqual(user_line_items.count(), 2)
for user_line_item in user_line_items:
self.assertIsNone(user_line_item.base_description)
self.assertEqual(user_line_item.base_cost, Decimal('0.0000'))
num_to_charge = num_users - self.user_rate.monthly_limit
self.assertEqual(num_to_charge, user_line_item.quantity)
if self.user_rate.feature.name == user_line_item.feature_rate.feature.name:
self.assertEqual(user_line_item.unit_cost,
self.user_rate.per_excess_fee)
self.assertEqual(user_line_item.total,
self.user_rate.per_excess_fee * num_to_charge)
self.assertEqual(user_line_item.subtotal,
self.user_rate.per_excess_fee * num_to_charge)
elif user_line_item.feature_rate.feature.name == self.advanced_rate.feature.name:
self.assertEqual(user_line_item.unit_cost,
self.advanced_rate.per_excess_fee)
self.assertEqual(
user_line_item.total,
self.advanced_rate.per_excess_fee * num_to_charge)
self.assertEqual(
user_line_item.subtotal,
self.advanced_rate.per_excess_fee * num_to_charge)
def get_daterange_start_end_dates(date_range,
start_date=None,
end_date=None,
days=None):
today = datetime.date.today()
if date_range == 'since':
start_date = start_date
end_date = today
elif date_range == 'range':
start_date = start_date
end_date = end_date
elif date_range == 'thismonth':
start_date, end_date = get_current_month_date_range()
elif date_range == 'lastmonth':
start_date, end_date = get_previous_month_date_range()
elif date_range == 'thisquarter':
start_date, end_date = get_current_quarter_date_range()
elif date_range == 'lastquarter':
start_date, end_date = get_previous_quarter_date_range()
elif date_range == 'lastyear':
last_year = today.year - 1
return datetime.date(last_year, 1, 1), datetime.date(last_year, 12, 31)
elif date_range == 'thisyear':
return datetime.date(today.year, 1,
1), datetime.date(today.year, 12, 31)
elif date_range == 'currentindianfinancialyear':
# financial year is from 1st April to 31st March
if today.month > 3:
return datetime.date(today.year, 4,
1), datetime.date(today.year + 1, 3, 31)
else:
return datetime.date(today.year - 1, 4,
1), datetime.date(today.year, 3, 31)
else:
end_date = today
days = {'last7': 7, 'last30': 30, 'lastn': days}.get(date_range)
if days is None:
raise InvalidDaterangeException
start_date = today - datetime.timedelta(days=days)
if start_date is None or end_date is None:
raise InvalidDaterangeException
return start_date, end_date
def test_sms_over_limit_in_yearly_invoice(self):
num_sms = random.randint(self.sms_rate.monthly_limit + 1,
self.sms_rate.monthly_limit + 2)
billables = arbitrary_sms_billables_for_domain(self.domain,
self.sms_date, num_sms)
num_sms_advanced = random.randint(
self.advanced_sms_rate.monthly_limit + 1,
self.advanced_sms_rate.monthly_limit + 2)
advanced_billables = arbitrary_sms_billables_for_domain(
self.domain2, self.sms_date, num_sms_advanced)
invoice_start, invoice_end = get_previous_month_date_range(
self.invoice_date)
invoice_start = invoice_start - relativedelta(months=11)
invoice_factory = CustomerAccountInvoiceFactory(
account=self.account,
date_start=invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
sms_line_items = invoice.lineitem_set.get_feature_by_type(
FeatureType.SMS)
self.assertEqual(sms_line_items.count(), 2)
for sms_line_item in sms_line_items:
self.assertIsNone(sms_line_item.base_description)
self.assertEqual(sms_line_item.base_cost, Decimal('0.0000'))
self.assertEqual(sms_line_item.quantity, 1)
if self.advanced_sms_rate.feature == sms_line_item.feature_rate.feature:
sms_cost = sum(
billable.gateway_charge + billable.usage_charge
for billable in
advanced_billables[self.advanced_sms_rate.monthly_limit:])
else:
sms_cost = sum(
billable.gateway_charge + billable.usage_charge
for billable in billables[self.sms_rate.monthly_limit:])
self.assertEqual(sms_line_item.unit_cost, sms_cost)
self.assertEqual(sms_line_item.total, sms_cost)
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_product_line_items_in_yearly_invoice(self):
self.account.invoicing_plan = InvoicingPlan.YEARLY
self.account.save()
invoice_date = utils.months_from_date(self.subscription.date_start, 14)
invoice_start, invoice_end = get_previous_month_date_range(
invoice_date)
invoice_start = invoice_start - relativedelta(months=11)
invoice_factory = CustomerAccountInvoiceFactory(
account=self.account,
date_start=invoice_start,
date_end=invoice_end)
invoice_factory.create_invoice()
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertGreater(invoice.balance, Decimal('0.0000'))
self.assertEqual(invoice.account, self.account)
# There should be two product line items, with 3 months billed for each
num_product_line_items = invoice.lineitem_set.get_products().count()
self.assertEqual(num_product_line_items, 2)
for product_line_item in invoice.lineitem_set.get_products().all():
self.assertEqual(product_line_item.quantity, 12)
def initialize_domain_user_history_objects(self):
record_dates = []
month_end = self.subscription.date_end
while month_end > self.subscription.date_start:
record_dates.append(month_end)
_, month_end = get_previous_month_date_range(month_end)
num_users = self.user_rate.monthly_limit + 1
for record_date in record_dates:
user_history = DomainUserHistory.create(
domain=self.domain,
num_users=num_users,
record_date=record_date
)
user_history.save()
num_users = self.advanced_rate.monthly_limit + 2
for record_date in record_dates:
user_history = DomainUserHistory.create(
domain=self.domain2,
num_users=num_users,
record_date=record_date
)
user_history.save()
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!")
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!")
