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 product_fixture_generator(user, version, last_sync):
if not user.domain:
return []
domain = Domain.get_by_name(user.domain)
if not domain or not Domain.get_by_name(user.domain).commtrack_enabled:
return []
root = ElementTree.Element('fixture',
attrib={'id': 'commtrack:products',
'user_id': user.user_id})
products = ElementTree.Element('products')
root.append(products)
for product_data in Product.by_domain(user.domain):
product = (ElementTree.Element('product',
{'id': product_data.get_id}))
products.append(product)
product_fields = ['name',
'unit',
'code',
'description',
'category',
'program_id',
'cost']
for product_field in product_fields:
field = ElementTree.Element(product_field)
field.text = unicode(getattr(product_data, product_field) or '')
product.append(field)
return [root]
def _copy(config):
# unfortunately the only couch view we have for this needs to go by domain
# will be a bit slow
database = Domain.get_db()
assert database.uri == config.source_db.uri, 'can only use "copy" with the main HQ DB as the source'
domain_names = Domain.get_all_names()
for domain in domain_names:
for doc_type in config.doc_types:
ids_of_this_type = [row['id'] for row in database.view(
'domain/docs',
startkey=[domain, doc_type],
endkey=[domain, doc_type, {}],
reduce=False,
include_docs=False,
)]
if ids_of_this_type:
new_revs = dict([
(row['id'], row['value']['rev'])
for row in config.dest_db.view('_all_docs', keys=ids_of_this_type, include_docs=False)
if 'error' not in row
])
for id_group in chunked(ids_of_this_type, 500):
docs = get_docs(database, id_group)
for doc in docs:
if doc['_id'] in new_revs:
doc['_rev'] = new_revs[doc['_id']]
config.dest_db.bulk_save(docs)
print 'copied {} {}s from {}'.format(len(ids_of_this_type), doc_type, domain)
print 'copy docs complete'
def setUp(self):
super(TestRenewSubscriptions, self).setUp()
self.domain = Domain(
name="test-domain-sub",
is_active=True,
)
self.domain.save()
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.domain.name, is_admin=True)
self.admin_user.save()
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.admin_user.username)[0]
self.standard_plan = DefaultProductPlan.get_default_plan_by_domain(
self.domain.name, edition=SoftwarePlanEdition.STANDARD)
today = datetime.date.today()
yesterday = today + datetime.timedelta(days=-1)
tomorrow = today + datetime.timedelta(days=1)
self.subscription = Subscription.new_domain_subscription(
self.account,
self.domain.name,
self.standard_plan,
web_user=self.admin_user.username,
date_start=yesterday,
date_end=tomorrow,
)
self.subscription.save()
def setUp(self):
super(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 handle(self, *args, **options):
if options.get("domain"):
domains = [Domain.get_by_name(options.get("domain"))]
else:
domains = Domain.get_all()
since = options.get("since")
seen_since = False
for d in domains:
if since and not seen_since:
if d.name == since:
seen_since = True
else:
continue
if d.name in DOMS_TO_IGNORE:
continue
try:
for app in d.full_applications():
try:
if app.is_remote_app():
continue
for _, m in app.get_media_objects():
if app.domain not in m.valid_domains:
m.valid_domains.append(app.domain)
self.stdout.write("adding domain %s to media file %s" % (app.domain, m._id))
m.save()
except Exception as e:
self.stdout.write("Error in app %s-%s: %s" % (app.domain, app._id, e))
except Exception as e:
self.stdout.write("Error in domain %s: %s" % (d.name, e))
def handle(self, *args, **options):
if options.get('domain'):
domains = [Domain.get_by_name(options.get('domain'))]
else:
domains = Domain.get_all()
since = options.get('since')
seen_since = False
for d in domains:
if since and not seen_since:
if d.name == since:
seen_since = True
else:
continue
if d.name in DOMS_TO_IGNORE:
continue
try:
for app in d.full_applications():
try:
if app.is_remote_app():
continue
for _, m in app.get_media_objects():
if app.domain not in m.valid_domains:
m.valid_domains.append(app.domain)
self.stdout.write(
"adding domain %s to media file %s" %
(app.domain, m._id))
m.save()
except Exception as e:
self.stdout.write("Error in app %s-%s: %s" %
(app.domain, app._id, e))
except Exception as e:
self.stdout.write("Error in domain %s: %s" % (d.name, e))
def setUp(self):
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
StockDataCheckpoint.objects.create(
domain='test',
api='test',
limit=100,
offset=0
)
StockDataCheckpoint.objects.create(
domain='test2',
api='test',
limit=100,
offset=0
)
MigrationCheckpoint.objects.create(
domain='test',
api='test',
limit=100,
offset=0
)
MigrationCheckpoint.objects.create(
domain='test2',
api='test',
limit=100,
offset=0
)
class TestRenewSubscriptions(BaseAccountingTest):
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_simple_renewal(self):
today = datetime.date.today()
new_end_date = today + datetime.timedelta(days=9)
renewed_subscription = self.subscription.renew_subscription(
date_end=new_end_date
)
self.assertEqual(renewed_subscription.date_end, new_end_date)
self.assertEqual(renewed_subscription.date_start, self.subscription.date_end)
self.assertEqual(renewed_subscription.plan_version, self.subscription.plan_version)
def test_change_plan_on_renewal(self):
today = datetime.date.today()
new_end_date = today + datetime.timedelta(days=9)
new_edition = SoftwarePlanEdition.ADVANCED
new_plan = DefaultProductPlan.get_default_plan_by_domain(self.domain.name, new_edition)
renewed_subscription = self.subscription.renew_subscription(
date_end=new_end_date,
new_version=new_plan
)
self.assertEqual(renewed_subscription.plan_version, new_plan)
class TestRenewSubscriptions(BaseAccountingTest):
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_simple_renewal(self):
today = datetime.date.today()
new_end_date = today + datetime.timedelta(days=9)
renewed_subscription = self.subscription.renew_subscription(
date_end=new_end_date)
self.assertEqual(renewed_subscription.date_end, new_end_date)
self.assertEqual(renewed_subscription.date_start,
self.subscription.date_end)
self.assertEqual(renewed_subscription.plan_version,
self.subscription.plan_version)
def test_change_plan_on_renewal(self):
today = datetime.date.today()
new_end_date = today + datetime.timedelta(days=9)
new_edition = SoftwarePlanEdition.ADVANCED
new_plan = DefaultProductPlan.get_default_plan_by_domain(
self.domain.name, new_edition)
renewed_subscription = self.subscription.renew_subscription(
date_end=new_end_date, new_version=new_plan)
self.assertEqual(renewed_subscription.plan_version, new_plan)
def setUp(self):
super(TestSubscription, 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.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user, self.billing_contact)
self.subscription, self.subscription_length = generator.generate_domain_subscription_from_date(
datetime.date.today(), self.account, self.domain.name
)
def tearDownClass(cls):
MobileBackend.load_by_name(TEST_DOMAIN, TEST_BACKEND).delete()
CommCareUser.get_by_username('stella').delete()
CommCareUser.get_by_username('super').delete()
delete_all_locations()
LocationType.objects.all().delete()
for product in Product.by_domain(TEST_DOMAIN):
product.delete()
SQLProduct.objects.all().delete()
EWSGhanaConfig.for_domain(TEST_DOMAIN).delete()
DocDomainMapping.objects.all().delete()
generator.delete_all_subscriptions()
Domain.get_by_name(TEST_DOMAIN).delete()
def tearDownClass(cls):
MobileBackend.load_by_name(TEST_DOMAIN, TEST_BACKEND).delete()
CommCareUser.get_by_username('stella').delete()
CommCareUser.get_by_username('super').delete()
delete_all_locations()
LocationType.objects.all().delete()
for product in Product.by_domain(TEST_DOMAIN):
product.delete()
SQLProduct.objects.all().delete()
EWSGhanaConfig.for_domain(TEST_DOMAIN).delete()
DocDomainMapping.objects.all().delete()
generator.delete_all_subscriptions()
Domain.get_by_name(TEST_DOMAIN).delete()
class TestSubscription(BaseAccountingTest):
def setUp(self):
super(TestSubscription, 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.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user, self.billing_contact)
self.subscription, self.subscription_length = generator.generate_domain_subscription_from_date(
datetime.date.today(), self.account, self.domain.name
)
def test_creation(self):
self.assertIsNotNone(self.subscription)
def test_no_activation(self):
tasks.activate_subscriptions(based_on_date=self.subscription.date_start - datetime.timedelta(30))
subscription = Subscription.objects.get(id=self.subscription.id)
self.assertFalse(subscription.is_active)
def test_activation(self):
tasks.activate_subscriptions(based_on_date=self.subscription.date_start)
subscription = Subscription.objects.get(id=self.subscription.id)
self.assertTrue(subscription.is_active)
def test_no_deactivation(self):
tasks.activate_subscriptions(based_on_date=self.subscription.date_start)
tasks.deactivate_subscriptions(based_on_date=self.subscription.date_end - datetime.timedelta(30))
subscription = Subscription.objects.get(id=self.subscription.id)
self.assertTrue(subscription.is_active)
def test_deactivation(self):
tasks.deactivate_subscriptions(based_on_date=self.subscription.date_end)
subscription = Subscription.objects.get(id=self.subscription.id)
self.assertFalse(subscription.is_active)
def test_deletions(self):
self.assertRaises(models.ProtectedError, self.account.delete)
self.assertRaises(models.ProtectedError, self.subscription.plan_version.delete)
self.assertRaises(models.ProtectedError, self.subscription.subscriber.delete)
def tearDown(self):
self.billing_contact.delete()
self.dimagi_user.delete()
self.domain.delete()
generator.delete_all_subscriptions()
generator.delete_all_accounts()
super(TestSubscription, self).tearDown()
def stock_data_submission(sender, cases, endpoint=None, **kwargs):
project = Domain.get_by_name(cases[0].domain)
if project.commtrack_enabled and project.commtrack_settings.openlmis_enabled:
if endpoint is None:
endpoint = OpenLMISEndpoint.from_config(project.commtrack_settings.openlmis_config)
# get agentCode and programCode - I assume all cases are part of the same program
agentCode = (cases[0].get_supply_point_case()).location.site_code
programCode = Program.get(cases[0].get_product().program_id).code
products = []
for case in cases:
product = case.get_product()
product_json = {'productCode': product.code}
product_json['stockInHand'] = int(case.get_default_value())
products.append(product_json)
stock_data = { 'agentCode': agentCode,
'programCode': programCode,
'products': products
}
response = sync_stock_data_to_openlmis(submission=stock_data, openlmis_endpoint=endpoint)
if response['requisitionId'] is not None:
for case in cases:
case.external_id = response['requisitionId']
case.save()
cases, send_notification = sync_requisition_from_openlmis(project.name, response['requisitionId'], endpoint)
if send_notification:
send_notifications(xform=None, cases=cases)
def stock_data_submission(sender, cases, endpoint=None, **kwargs):
project = Domain.get_by_name(cases[0].domain)
if project.commtrack_enabled and project.commtrack_settings.openlmis_enabled:
if endpoint is None:
endpoint = OpenLMISEndpoint.from_config(project.commtrack_settings.openlmis_config)
# get agentCode and programCode - I assume all cases are part of the same program
agentCode = (cases[0].get_supply_point_case()).location.site_code
programCode = Program.get(cases[0].get_product().program_id).code
products = []
for case in cases:
product = case.get_product()
product_json = {'productCode': product.code}
product_json['stockInHand'] = int(case.get_default_value())
products.append(product_json)
stock_data = { 'agentCode': agentCode,
'programCode': programCode,
'products': products
}
response = sync_stock_data_to_openlmis(submission=stock_data, openlmis_endpoint=endpoint)
if response['requisitionId'] is not None:
for case in cases:
case.external_id = response['requisitionId']
case.save()
cases, send_notification = sync_requisition_from_openlmis(project.name, response['requisitionId'], endpoint)
if send_notification:
send_notifications(xform=None, cases=cases)
def location_restriction_for_users(request, domain):
project = Domain.get_by_name(domain)
if "restrict_users" in request.POST:
project.location_restriction_for_users = json.loads(
request.POST["restrict_users"])
project.save()
return HttpResponse()
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 update_careplan_config(config, parent_app_id, application):
app_props = config.app_configs.get(parent_app_id, CareplanAppProperties())
app_props.latest_release = application.get_id
for module in application.get_modules():
if isinstance(module, CareplanModule):
app_props.name = module.default_name()
app_props.case_type = module.case_type
app_props.goal_conf = {
"edit_module_id":
module.id,
"edit_form_id":
module.get_form_by_type(CAREPLAN_GOAL, 'update').id,
"create_module_id":
module.id,
"create_form_id":
module.get_form_by_type(CAREPLAN_GOAL, 'create').id,
}
app_props.task_conf = {
"edit_module_id":
module.id,
"edit_form_id":
module.get_form_by_type(CAREPLAN_TASK, 'update').id,
"create_module_id":
module.id,
"create_form_id":
module.get_form_by_type(CAREPLAN_TASK, 'create').id,
}
break
config.app_configs[parent_app_id] = app_props
config.save()
domain = Domain.get_by_name(application.domain)
if not domain.has_careplan:
domain.has_careplan = True
domain.save()
def update_careplan_config(config, parent_app_id, application):
app_props = config.app_configs.get(parent_app_id, CareplanAppProperties())
app_props.latest_release = application.get_id
for module in application.get_modules():
if isinstance(module, CareplanModule):
app_props.name = module.default_name()
app_props.case_type = module.case_type
app_props.goal_conf = {
"edit_module_id": module.id,
"edit_form_id": module.get_form_by_type(CAREPLAN_GOAL, 'update').id,
"create_module_id": module.id,
"create_form_id": module.get_form_by_type(CAREPLAN_GOAL, 'create').id,
}
app_props.task_conf = {
"edit_module_id": module.id,
"edit_form_id": module.get_form_by_type(CAREPLAN_TASK, 'update').id,
"create_module_id": module.id,
"create_form_id": module.get_form_by_type(CAREPLAN_TASK, 'create').id,
}
break
config.app_configs[parent_app_id] = app_props
config.save()
domain = Domain.get_by_name(application.domain)
if not domain.has_careplan:
domain.has_careplan = True
domain.save()
def handle(self, *args, **options):
domain = args[0]
db = Domain.get_db()
doc_ids = [
r['id'] for r in db.view(
'domain/docs',
startkey=[domain, 'RepeatRecord'],
endkey=[domain, 'RepeatRecord', {}],
reduce=False,
)
]
count = len(doc_ids)
print 'found %s doc ids' % count
latest = datetime.min
latest_doc = None
for i, doc in enumerate(iter_docs(db, doc_ids)):
wrapped = RepeatRecord.wrap(doc)
if i % 100 == 0:
print 'checked %s / %s' % (i, count)
if wrapped.last_checked and wrapped.last_checked > latest:
latest = wrapped.last_checked
latest_doc = wrapped
print 'new latest: %s' % latest
if latest_doc:
print 'latest repeater date is %s' % latest
print 'latest repeater is %s' % latest_doc._id
else:
print 'no relevant repeaters found'
def handle(self, *args, **options):
if len(args) != 1:
print "Invalid arguments: %s" % str(args)
return
domain = Domain.get_by_name(args[0])
if not domain:
print "Invalid domain name: %s" % args[0]
return
account, _ = BillingAccount.get_or_create_account_by_domain(
domain.name,
account_type=BillingAccountType.CONTRACT,
created_by="management command",
)
enterprise_plan_version = SoftwarePlanVersion.objects.filter(
plan__edition=SoftwarePlanEdition.ENTERPRISE
)[0]
try:
subscription = Subscription.new_domain_subscription(
account,
domain.name,
enterprise_plan_version
)
except NewSubscriptionError as e:
print e.message
return
subscription.is_active = True
subscription.save()
print 'Domain %s has been upgraded to enterprise level.' % domain.name
def filter_context(self):
api_root = reverse('api_dispatch_list', kwargs={'domain': self.domain,
'resource_name': 'location',
'api_name': 'v0.3'})
selected_loc_id = self.request.GET.get('location_id')
user = CouchUser.get_by_username(unicode(self.request.user))
domain = Domain.get_by_name(self.domain)
context = {}
location_id = None
domain_membership = user.get_domain_membership(self.domain)
if domain_membership:
location_id = domain_membership.location_id
if not selected_loc_id and location_id and domain.commtrack_enabled:
selected_loc_id = location_id
if domain.location_restriction_for_users:
context.update({'restriction': domain.location_restriction_for_users})
context.update({
'api_root': api_root,
'control_name': self.label, # todo: cleanup, don't follow this structure
'control_slug': self.slug, # todo: cleanup, don't follow this structure
'loc_id': selected_loc_id,
'locations': json.dumps(load_locs_json(self.domain, selected_loc_id)),
'hierarchy': location_hierarchy_config(self.domain)
})
return context
def handle(self, *args, **options):
billables_created = 0
for domain in Domain.get_all():
key = [domain.name, 'SMSLog']
start_date = [datetime.datetime(2014, 1, 1).isoformat()]
end_date = [datetime.datetime(2014, 1, 24).isoformat()]
sms_docs = SMSLog.get_db().view('sms/by_domain',
reduce=False,
startkey=key + start_date,
endkey=key + end_date + [{}])
for sms_doc in sms_docs:
sms_log = SMSLog.get(sms_doc['id'])
try:
if sms_log.phone_number is not None:
parse_phone_number(sms_log.phone_number)
except PhoneNumberParseException:
billables = SmsBillable.objects.filter(log_id=sms_log._id)
if len(billables) == 0:
SmsBillable.create(sms_log)
billables_created += 1
print 'created SmsBillable for invalid number %s in domain %s, id=%s'\
% (sms_log.phone_number, domain.name, sms_log._id)
elif len(billables) > 1:
print "Warning: >1 SmsBillable exists for SMSLog with id=%" % sms_log._id
print 'Number of SmsBillables created: %d' % billables_created
print 'Completed retrobilling.'
def enable_usercase(domain_name):
with CriticalSection(['enable_usercase_' + domain_name]):
domain = Domain.get_by_name(domain_name, strict=True)
if not domain.usercase_enabled:
domain.usercase_enabled = True
domain.save()
create_user_cases.delay(domain_name)
def get_settings_values(app):
try:
profile = app.profile
except AttributeError:
profile = {}
hq_settings = dict([(attr, app[attr]) for attr in app.properties()
if not hasattr(app[attr], 'pop')])
if getattr(app, 'use_custom_suite', False):
hq_settings.update(
{'custom_suite': getattr(app, 'custom_suite', None)})
hq_settings['build_spec'] = app.build_spec.to_string()
# the admin_password hash shouldn't be sent to the client
hq_settings.pop('admin_password', None)
domain = Domain.get_by_name(app.domain)
return {
'properties': profile.get('properties', {}),
'features': profile.get('features', {}),
'hq': hq_settings,
'$parent': {
'doc_type': app.get_doc_type(),
'_id': app.get_id,
'domain': app.domain,
'commtrack_enabled': domain.commtrack_enabled,
}
}
def handle(self, *args, **options):
num_sms = 0
start_datetime = datetime.datetime(*str_to_int_tuple(args[0:6]))
end_datetime = datetime.datetime(*str_to_int_tuple(args[6:12]))
for domain in Domain.get_all():
key = [domain.name, 'SMSLog']
sms_docs = SMSLog.get_db().view('sms/by_domain',
reduce=False,
startkey=key + [start_datetime.isoformat()],
endkey=key + [end_datetime.isoformat(), {}],
)
for sms_doc in sms_docs:
sms_log = SMSLog.get(sms_doc['id'])
if options.get('create', False):
SmsBillable.create(sms_log)
print 'Created billable for SMSLog %s in domain %s from %s' \
% (sms_doc['id'], domain.name, sms_log.date)
else:
print 'Found SMSLog %s in domain %s from %s' \
% (sms_doc['id'], domain.name, sms_log.date)
num_sms += 1
print 'Number of SMSs in datetime range: %d' % num_sms
def invite(self, invitation, user):
project = Domain.get_by_name(self.domain)
user.add_domain_membership(domain=self.domain)
user.set_role(self.domain, invitation.role)
if project.commtrack_enabled and not project.location_restriction_for_users:
user.location_id = invitation.supply_point
user.save()
def __init__(self,
domain,
new_plan_version,
changed_privs,
verbose=False,
date_start=None,
web_user=None):
self.web_user = web_user
self.verbose = verbose
self.date_start = date_start or datetime.date.today()
if isinstance(changed_privs, set):
changed_privs = list(changed_privs)
if not isinstance(domain, Domain):
domain = Domain.get_by_name(domain)
self.domain = domain
# plan dependent privilege
changed_privs.append(privileges.MOBILE_WORKER_CREATION)
# check to make sure that no subscriptions are scheduled to
# start in the future
changed_privs.append(LATER_SUBSCRIPTION_NOTIFICATION)
self.privileges = filter(lambda x: x in self.supported_privileges,
changed_privs)
self.new_plan_version = new_plan_version
def get_settings_values(app):
try:
profile = app.profile
except AttributeError:
profile = {}
hq_settings = dict([
(attr, app[attr])
for attr in app.properties() if not hasattr(app[attr], 'pop')
])
if getattr(app, 'use_custom_suite', False):
hq_settings.update({'custom_suite': getattr(app, 'custom_suite', None)})
hq_settings['build_spec'] = app.build_spec.to_string()
# the admin_password hash shouldn't be sent to the client
hq_settings.pop('admin_password', None)
domain = Domain.get_by_name(app.domain)
return {
'properties': profile.get('properties', {}),
'features': profile.get('features', {}),
'hq': hq_settings,
'$parent': {
'doc_type': app.get_doc_type(),
'_id': app.get_id,
'domain': app.domain,
'commtrack_enabled': domain.commtrack_enabled,
}
}
def options(self):
return clean_options(
[
(domain.name, domain.name)
for domain in Domain.get_all()
]
)
class TestBillingRecord(BaseAccountingTest):
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, self.subscription_length = generator.generate_domain_subscription_from_date(
datetime.date.today(), self.account, self.domain.name
)
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 test_should_send_email(self):
self.assertTrue(self.billing_record.should_send_email)
def test_should_send_email_contracted(self):
self.subscription.service_type = SubscriptionType.CONTRACTED
self.assertFalse(self.billing_record.should_send_email)
self.invoice.balance = Decimal(SMALL_INVOICE_THRESHOLD - 1)
self.assertFalse(self.billing_record.should_send_email)
self.invoice.balance = Decimal(SMALL_INVOICE_THRESHOLD + 1)
self.assertTrue(self.billing_record.should_send_email)
def test_should_send_email_autogenerate_credits(self):
self.subscription.auto_generate_credits = True
self.assertFalse(self.billing_record.should_send_email)
self.invoice.balance = Decimal(SMALL_INVOICE_THRESHOLD + 1)
self.assertTrue(self.billing_record.should_send_email)
def test_should_send_email_hidden(self):
self.assertTrue(self.billing_record.should_send_email)
self.invoice.is_hidden = True
self.assertFalse(self.billing_record.should_send_email)
def can_edit_form_location(domain, user, form):
if not toggles.RESTRICT_FORM_EDIT_BY_LOCATION.enabled(domain):
return True
location = get_xform_location(form)
if not location:
return True
return user_can_edit_location(user, location, Domain.get_by_name(domain))
def setUpClass(cls):
cls.domain = Domain(name='foo')
cls.domain.save()
cls.user = CommCareUser.create(cls.domain.name, 'somebody', 'password')
cls.user_id = cls.user._id
cls.factory = CaseFactory(domain='foo',
case_defaults={'owner_id': cls.user_id})
ENABLE_LOADTEST_USERS.set('foo', True, namespace='domain')
def setUp(self):
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.locations = {}
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
self._create_data('test')
self._create_data('test2')
def confirm_delivery(sender, requisitions, **kwargs):
if requisitions and requisitions[
0].requisition_status == RequisitionStatus.RECEIVED:
project = Domain.get_by_name(requisitions[0].domain)
if project.commtrack_enabled and project.commtrack_settings.openlmis_enabled:
endpoint = OpenLMISEndpoint.from_config(
project.commtrack_settings.openlmis_config)
delivery_update(requisitions, endpoint)
def setUp(self):
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.locations = {}
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
self._create_data('test')
self._create_data('test2')
def approve_requisitions(sender, requisitions, **kwargs):
if requisitions and requisitions[
0].requisition_status == RequisitionStatus.APPROVED:
project = Domain.get_by_name(requisitions[0].domain)
if project.commtrack_enabled and project.commtrack_settings.openlmis_enabled:
endpoint = OpenLMISEndpoint.from_config(
project.commtrack_settings.openlmis_config)
approve_requisition(requisitions, endpoint)
def get_locations(self):
location_types = [
location_type.name
for location_type in Domain.get_by_name(self.domain).location_types
if location_type.administrative
]
return SQLLocation.objects.filter(parent__location_id=self.config['location_id'],
location_type__name__in=location_types, is_archived=False)
def location_restriction_for_users(request, domain):
if not toggles.RESTRICT_WEB_USERS_BY_LOCATION.enabled(request.domain):
raise Http403()
project = Domain.get_by_name(domain)
if "restrict_users" in request.POST:
project.location_restriction_for_users = json.loads(request.POST["restrict_users"])
project.save()
return HttpResponse()
def invite(self, invitation, user):
project = Domain.get_by_name(self.domain)
user.add_domain_membership(domain=self.domain)
user.set_role(self.domain, invitation.role)
if project.commtrack_enabled and not project.location_restriction_for_users:
user.get_domain_membership(self.domain).location_id = invitation.supply_point
user.get_domain_membership(self.domain).program_id = invitation.program
user.save()
def facilities(self, **kwargs):
reporting_types = [
loc_type.name for loc_type in Domain.get_by_name(self.config['domain']).location_types
if not loc_type.administrative
]
return SQLLocation.objects.filter(domain=self.domain,
location_type__in=reporting_types,
**kwargs)
def get_locations(self):
location_types = [
loc_type.name for loc_type in filter(lambda loc_type: loc_type.administrative,
Domain.get_by_name(self.config['domain']).location_types
)
]
return SQLLocation.objects.filter(parent__location_id=self.config['location_id'],
location_type__in=location_types)
def supply_point_updated(sender, supply_point, created, **kwargs):
project = Domain.get_by_name(supply_point.domain)
if project.commtrack_enabled and project.commtrack_settings.openlmis_enabled:
# check if supply_point is of 'chw type'
if supply_point.location and supply_point.location.location_type == "chw":
#check if supply_point is linked to an OpenLMIS facility
if supply_point.location.lineage and len(supply_point.location.lineage) > 0:
endpoint = OpenLMISEndpoint.from_config(project.commtrack_settings.openlmis_config)
sync_supply_point_to_openlmis(supply_point, endpoint, created)
def careplan_removed(domain_name, config, app_id):
if config and app_id in config.app_configs:
del config.app_configs[app_id]
config.save()
if not config.app_configs:
domain = Domain.get_by_name(domain_name)
domain.has_careplan = False
domain.save()
def careplan_removed(domain_name, config, app_id):
if config and app_id in config.app_configs:
del config.app_configs[app_id]
config.save()
if not config.app_configs:
domain = Domain.get_by_name(domain_name)
domain.has_careplan = False
domain.save()
def domain_response(self):
domain_names = [
domain['key'] for domain in Domain.get_all(include_docs=False)
]
if self.search_string:
domain_names = filter(
lambda x: x.lower().startswith(self.search_string.lower()),
domain_names)
return [(d, d) for d in domain_names]
def subscribed_domains(self):
if self.subscription.subscriber.organization is None and self.subscription.subscriber.domain is None:
raise LineItemError(
"No domain or organization could be obtained as the subscriber."
)
if self.subscription.subscriber.organization is not None:
return Domain.get_by_organization(
self.subscription.subscriber.organization)
return [self.subscription.subscriber.domain]
def supply_point_updated(sender, supply_point, created, **kwargs):
project = Domain.get_by_name(supply_point.domain)
if project.commtrack_enabled and project.commtrack_settings.openlmis_enabled:
# check if supply_point is of 'chw type'
if supply_point.location and supply_point.location.location_type == "chw":
#check if supply_point is linked to an OpenLMIS facility
if supply_point.location.lineage and len(supply_point.location.lineage) > 0:
endpoint = OpenLMISEndpoint.from_config(project.commtrack_settings.openlmis_config)
sync_supply_point_to_openlmis(supply_point, endpoint, created)
def location_restriction_for_users(request, domain):
if not toggles.RESTRICT_WEB_USERS_BY_LOCATION.enabled(request.domain):
raise Http403()
project = Domain.get_by_name(domain)
if "restrict_users" in request.POST:
project.location_restriction_for_users = json.loads(
request.POST["restrict_users"])
project.save()
return HttpResponse()
def _create_location_type_if_not_exists(self, supply_point, location):
domain = Domain.get_by_name(self.domain)
if not filter(lambda l: l.name == supply_point.type, domain.location_types):
domain.location_types.append(LocationType(
name=supply_point.type,
allowed_parents=[location.location_type],
administrative=False
))
domain.save()
def handle(self, doc_types, *args, **options):
input = raw_input('\n'.join([
'\n\nReally delete documents of the following types: {}?',
'This operation is not reversible. Enter a number N to delete the first '
'N found, or type "delete all" to delete everything.',
'',
]).format(doc_types))
if input == 'delete all':
remaining = None
else:
try:
remaining = int(input)
except ValueError:
print 'aborting'
sys.exit()
doc_types = doc_types.split(',')
deleted = 0
# unfortunately the only couch view we have for this needs to go by domain
# will be a bit slow
domain_names = Domain.get_all_names()
database = Domain.get_db()
for domain in domain_names:
for doc_type in doc_types:
docs = [row['doc'] for row in database.view(
'domain/docs',
startkey=[domain, doc_type],
endkey=[domain, doc_type, {}],
reduce=False,
include_docs=True,
)][:remaining]
if docs:
count = len(docs)
print 'deleting {} {}s from {}'.format(count, doc_type, domain)
database.delete_docs(docs)
deleted += count
if remaining is not None:
remaining -= count
if remaining <= 0:
return
print 'successfully deleted {} documents'.format(deleted)
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, self.subscription_length = generator.generate_domain_subscription_from_date(
datetime.date.today(), self.account, self.domain.name
)
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)
