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!")