def setUpClass(cls):
super(GetRestoreUserTest, cls).setUpClass()
cls.project = Domain(name=cls.domain)
cls.project.save()
cls.other_project = Domain(name=cls.other_domain)
cls.other_project.save()
cls.web_user = WebUser.create(
username='******',
domain=cls.domain,
password='******',
)
cls.commcare_user = CommCareUser.create(
username=format_username('jane', cls.domain),
domain=cls.domain,
password='******',
)
cls.other_commcare_user = CommCareUser.create(
username=format_username('john', cls.domain),
domain=cls.domain,
password='******',
)
cls.super_user = WebUser.create(
username='******',
domain=cls.other_domain,
password='******',
)
cls.super_user.is_superuser = True
cls.super_user.save()
def setUpClass(cls):
cls.domain = 'my-test-views'
cls.username = '******'
cls.regular_name = 'ron'
cls.password = '******'
cls.user = WebUser.create(cls.domain, cls.username, cls.password, is_active=True)
cls.user.is_superuser = True
cls.user.save()
cls.mobile_worker = CommCareUser.create('potter', '*****@*****.**', '123')
cls.regular = WebUser.create(cls.domain, cls.regular_name, cls.password, is_active=True)
def setUpClass(cls):
super(RestorePermissionsTest, cls).setUpClass()
cls.other_project = Domain(name=cls.other_domain)
cls.other_project.save()
cls.web_user = WebUser.create(
username='******',
domain=cls.domain,
password='******',
)
cls.super_user = WebUser.create(
username='******',
domain=cls.other_domain,
password='******',
)
cls.super_user.is_superuser = True
cls.super_user.save()
cls.commcare_user = CommCareUser.create(
username=format_username('super', cls.domain),
domain=cls.domain,
password='******',
)
cls.no_edit_commcare_user = CommCareUser.create(
username=format_username('noedit', cls.domain),
domain=cls.domain,
password='******',
)
cls.location_user = CommCareUser.create(
username=format_username('location', cls.domain),
domain=cls.domain,
password='******',
)
cls.wrong_location_user = CommCareUser.create(
username=format_username('wrong-location', cls.domain),
domain=cls.domain,
password='******',
)
cls.web_location_user = WebUser.create(
username='******',
domain=cls.domain,
password='******',
)
cls.commcare_user.set_location(cls.locations['usa'])
cls.web_location_user.set_location(cls.domain, cls.locations['usa'])
cls.no_edit_commcare_user.set_location(cls.locations['usa'])
cls.location_user.set_location(cls.locations['ma'])
cls.wrong_location_user.set_location(cls.locations['montreal'])
cls.restrict_user_to_assigned_locations(cls.commcare_user)
cls.restrict_user_to_assigned_locations(cls.web_location_user)
def setUpClass(cls):
super(AuthenticateAsIntegrationTest, cls).setUpClass()
cls.domain = Domain(name="my-test-views")
cls.domain.save()
cls.username = "******"
cls.regular_name = "ron"
cls.password = "******"
cls.user = WebUser.create(cls.domain.name, cls.username, cls.password, is_active=True)
cls.user.is_superuser = True
cls.user.save()
cls.mobile_worker = CommCareUser.create("potter", "*****@*****.**", "123")
cls.regular = WebUser.create(cls.domain.name, cls.regular_name, cls.password, is_active=True)
def testDomainMemberships(self):
w_username = "******"
w_email = "*****@*****.**"
w2_username = "******"
w2_email = "*****@*****.**"
cc_username = "******"
password = "******"
domain = "test-domain"
# check that memberships are added on creation
webuser = WebUser.create(domain, w_username, password, w_email)
webuser2 = WebUser.create('nodomain', w2_username, password, w2_email)
ccuser = CommCareUser.create(domain, cc_username, password)
self.assertEquals(webuser.is_member_of('test-domain'), True)
self.assertEquals(ccuser.is_member_of('test-domain'), True)
# getting memberships
self.assertEquals(webuser.get_domain_membership(domain).domain, domain)
self.assertEquals(ccuser.get_domain_membership(domain).domain, domain)
permission_to = 'view_reports'
self.assertEquals(webuser.has_permission(domain, permission_to), False)
self.assertEquals(ccuser.has_permission(domain, permission_to), False)
webuser.set_role(domain, "field-implementer")
ccuser.set_role(domain, "field-implementer")
self.assertEquals( webuser.get_domain_membership(domain).role_id,
ccuser.get_domain_membership(domain).role_id)
self.assertEquals(webuser.role_label(), ccuser.role_label())
self.assertEquals(webuser.has_permission(domain, permission_to), True)
self.assertEquals(ccuser.has_permission(domain, permission_to), True)
self.assertEquals(webuser.is_domain_admin(domain), False)
self.assertEquals(ccuser.is_domain_admin(domain), False)
# deleting memberships
webuser.delete_domain_membership(domain)
with self.assertRaises(NotImplementedError):
ccuser.delete_domain_membership(domain)
self.assertEquals(webuser.is_member_of(domain), False)
self.assertEquals(webuser2.is_member_of(domain), False)
self.assertEquals(ccuser.is_member_of(domain), True)
self.assertEquals(ccuser.get_domain_membership(domain).domain, domain)
webuser.add_domain_membership(domain)
webuser.transfer_domain_membership(domain, webuser2)
self.assertEquals(webuser.is_member_of(domain), False)
self.assertEquals(webuser2.is_member_of(domain), True)
def setUpClass(cls):
super(SchedulingRecipientTest, cls).setUpClass()
cls.domain_obj = create_domain(cls.domain)
cls.location_types = setup_location_types(cls.domain, ['country', 'state', 'city'])
cls.country_location = make_loc('usa', domain=cls.domain, type='country')
cls.state_location = make_loc('ma', domain=cls.domain, type='state', parent=cls.country_location)
cls.city_location = make_loc('boston', domain=cls.domain, type='city', parent=cls.state_location)
cls.mobile_user = CommCareUser.create(cls.domain, 'mobile', 'abc')
cls.mobile_user.set_location(cls.city_location)
cls.mobile_user2 = CommCareUser.create(cls.domain, 'mobile2', 'abc')
cls.mobile_user2.set_location(cls.state_location)
cls.mobile_user3 = CommCareUser.create(cls.domain, 'mobile3', 'abc')
cls.mobile_user3.user_data['role'] = 'pharmacist'
cls.mobile_user3.save()
cls.mobile_user4 = CommCareUser.create(cls.domain, 'mobile4', 'abc')
cls.mobile_user4.user_data['role'] = 'nurse'
cls.mobile_user4.save()
cls.mobile_user5 = CommCareUser.create(cls.domain, 'mobile5', 'abc')
cls.mobile_user5.user_data['role'] = ['nurse', 'pharmacist']
cls.mobile_user5.save()
cls.web_user = WebUser.create(cls.domain, 'web', 'abc')
cls.web_user2 = WebUser.create(cls.domain, 'web2', 'abc')
cls.web_user2.user_data['role'] = 'nurse'
cls.web_user2.save()
cls.group = Group(domain=cls.domain, users=[cls.mobile_user.get_id])
cls.group.save()
cls.group2 = Group(
domain=cls.domain,
users=[
cls.mobile_user.get_id,
cls.mobile_user3.get_id,
cls.mobile_user4.get_id,
cls.mobile_user5.get_id,
]
)
cls.group2.save()
cls.case_group = CommCareCaseGroup(domain=cls.domain)
cls.case_group.save()
def setUpClass(cls):
super(FormEditRestrictionsMixin, cls).setUpClass()
cls.middlesex_web_user = cls.make_web_user('Middlesex')
cls.massachusetts_web_user = cls.make_web_user('Massachusetts')
cambridge_user = cls.make_mobile_user('Cambridge')
cls.cambridge_form = cls.make_form(cambridge_user)
boston_user = cls.make_mobile_user('Boston')
cls.boston_form = cls.make_form(boston_user)
cls.locationless_web_user = WebUser.create(cls.domain, 'joeshmoe', 'password')
cls.project_admin = WebUser.create(cls.domain, 'kennedy', 'password')
def setUpClass(cls):
w_username = "******"
w_email = "*****@*****.**"
w2_username = "******"
w2_email = "*****@*****.**"
cc_username = "******"
password = "******"
cls.domain_obj = create_domain(cls.domain)
cls.nodomain_obj = create_domain('nodomain')
cls.project = Domain(name=cls.domain)
cls.project.save()
cls.webuser = WebUser.create(cls.domain, w_username, password, w_email)
cls.webuser2 = WebUser.create('nodomain', w2_username, password, w2_email)
cls.ccuser = CommCareUser.create(cls.domain, cc_username, password)
def test_get_scheduled_report_response(self):
domain = 'test-scheduled-reports'
user = WebUser.create(
domain=domain,
username='******',
password='******',
)
report_config = ReportConfig.wrap({
"date_range": "last30",
"days": 30,
"domain": domain,
"report_slug": "worker_activity",
"report_type": "project_report",
"owner_id": user._id,
})
report_config.save()
report = ReportNotification(
hour=12, minute=None, day=30, interval='monthly', config_ids=[report_config._id]
)
report.save()
response = get_scheduled_report_response(
couch_user=user, domain=domain, scheduled_report_id=report._id
)[0]
self.assertEqual(200, response.status_code)
self.assertTrue(user.username in response.serialize())
def test_update(self):
self.client.login(username=self.username, password=self.password)
user = WebUser.create(domain=self.domain.name, username="******", password="******")
user_json = {
"email":"*****@*****.**",
"first_name":"Joe",
"is_admin": True,
"last_name":"Admin",
"permissions":{
"edit_apps":True,
"edit_commcare_users":True,
"edit_data":True,
"edit_web_users":True,
"view_reports":True
},
"phone_numbers":[
],
"role":"admin"
}
backend_id = user._id
response = self.client.put(self.single_endpoint(backend_id),
simplejson.dumps(user_json),
content_type='application/json')
self.assertEqual(response.status_code, 204, response.content)
modified = WebUser.get(backend_id)
self.assertEqual(modified.username, "test")
self.assertEqual(modified.first_name, "Joe")
self.assertEqual(modified.last_name, "Admin")
self.assertEqual(modified.email, "*****@*****.**")
modified.delete()
def test_get_list(self):
self.client.login(username=self.username, password=self.password)
response = self.client.get(self.list_endpoint)
self.assertEqual(response.status_code, 200)
api_users = json.loads(response.content)["objects"]
self.assertEqual(len(api_users), 1)
self._check_user_data(self.user, api_users[0])
another_user = WebUser.create(self.domain.name, "anotherguy", "***")
another_user.set_role(self.domain.name, "field-implementer")
another_user.save()
response = self.client.get(self.list_endpoint)
self.assertEqual(response.status_code, 200)
api_users = json.loads(response.content)["objects"]
self.assertEqual(len(api_users), 2)
# username filter
response = self.client.get("%s?username=%s" % (self.list_endpoint, "anotherguy"))
self.assertEqual(response.status_code, 200)
api_users = json.loads(response.content)["objects"]
self.assertEqual(len(api_users), 1)
self._check_user_data(another_user, api_users[0])
response = self.client.get("%s?username=%s" % (self.list_endpoint, "nomatch"))
self.assertEqual(response.status_code, 200)
api_users = json.loads(response.content)["objects"]
self.assertEqual(len(api_users), 0)
def test_users(self):
from corehq.apps.users.models import CommCareUser
from corehq.apps.users.models import WebUser
from django.contrib.auth.models import User
expected_object_counts = Counter({User: 3})
ccuser_1 = CommCareUser.create(
domain=self.domain_name,
username='******',
password='******',
email='*****@*****.**',
)
ccuser_2 = CommCareUser.create(
domain=self.domain_name,
username='******',
password='******',
email='*****@*****.**',
)
web_user = WebUser.create(
domain=self.domain_name,
username='******',
password='******',
email='*****@*****.**',
)
self.addCleanup(ccuser_1.delete)
self.addCleanup(ccuser_2.delete)
self.addCleanup(web_user.delete)
self._dump_and_load(expected_object_counts)
def bootstrap_web_user(
domain,
username,
password,
email,
location,
user_data=None,
phone_number="",
first_name="",
last_name="",
program_id=None,
):
web_user = WebUser.create(domain=domain, username=username, password=password, email=email)
web_user.first_name = first_name
web_user.last_name = last_name
web_user.user_data = user_data or {}
web_user.set_location(domain, location)
dm = web_user.get_domain_membership(domain)
dm.program_id = program_id
if phone_number:
web_user.phone_numbers = [phone_number]
web_user.save()
return web_user
def setUp(self):
self.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
self.username = '******'
self.password = '******'
self.user = WebUser.create(self.domain.name, self.username, self.password)
self.user.set_role(self.domain.name, 'admin')
self.user.save()
def activate_new_user(form, is_domain_admin=True, domain=None, ip=None):
username = form.cleaned_data['email']
password = form.cleaned_data['password']
full_name = form.cleaned_data['full_name']
email_opt_out = form.cleaned_data['email_opt_out']
now = datetime.utcnow()
new_user = WebUser.create(domain, username, password, is_admin=is_domain_admin)
new_user.first_name = full_name[0]
new_user.last_name = full_name[1]
new_user.email = username
new_user.email_opt_out = email_opt_out
new_user.eula.signed = True
new_user.eula.date = now
new_user.eula.type = 'End User License Agreement'
if ip: new_user.eula.user_ip = ip
new_user.is_staff = False # Can't log in to admin site
new_user.is_active = True
new_user.is_superuser = False
new_user.last_login = now
new_user.date_joined = now
new_user.save()
return new_user
def handle(self, *args, **options):
from corehq.apps.users.models import WebUser
if len(args) != 3:
raise CommandError('Usage: manage.py bootstrap <domain> <email> <password>')
domain_name, username, passwd = args
domain = Domain.get_or_create_with_name(domain_name, is_active=True)
couch_user = WebUser.get_by_username(username)
membership = None
if couch_user:
if not isinstance(couch_user, WebUser):
raise CommandError('Username already in use by a non-web user')
membership = couch_user.get_domain_membership(domain_name)
else:
couch_user = WebUser.create(domain_name, username, passwd)
if not membership:
couch_user.add_domain_membership(domain_name, is_admin=True)
couch_user.is_superuser = True
couch_user.is_staff = True
couch_user.save()
print "user %s created and added to domain %s" % (couch_user.username, domain)
if not getattr(settings, 'BASE_ADDRESS', None):
print ("Warning: You must set BASE_ADDRESS setting "
"in your localsettings.py file in order for commcare-hq "
"to be able to generate absolute urls. "
"This is necessary for a number of features.")
def setUpClass(cls):
super(UserAnalyticsTest, cls).setUpClass()
delete_all_users()
cls.domain = create_domain('test')
cls.active_user = CommCareUser.create(
domain='test',
username='******',
password='******',
is_active=True,
)
cls.active_user_2 = CommCareUser.create(
domain='test',
username='******',
password='******',
is_active=True,
)
cls.inactive_user = CommCareUser.create(
domain='test',
username='******',
password='******',
is_active=False
)
cls.web_user = WebUser.create(
domain='test',
username='******',
password='******',
)
update_analytics_indexes()
def setUp(self):
domain = 'test'
username = "******"
password = "******"
self.domain_obj = create_domain(domain)
self.web_user = WebUser.create(domain, username, password)
self.web_user.save()
def setUpClass(cls):
cls.domain = 'test-domain'
cls.domain_obj = create_domain(cls.domain)
bootstrap_location_types(cls.domain)
delete_all_locations()
delete_all_users()
def make_user(name, location):
user = CommCareUser.create(cls.domain, name, 'password')
user.set_location(location)
return user
cls.meereen = make_loc('meereen', type='outlet', domain=cls.domain)
cls.pentos = make_loc('pentos', type='outlet', domain=cls.domain)
cls.varys = make_user('Varys', cls.pentos)
cls.tyrion = make_user('Tyrion', cls.meereen)
cls.daenerys = make_user('Daenerys', cls.meereen)
cls.george = WebUser.create(
cls.domain,
username="******",
password='******'
)
cls.george.set_location(cls.domain, cls.meereen)
def setUpClass(cls):
cls.ccdomain = Domain(name='cc_user_domain')
cls.ccdomain.save()
cls.other_domain = Domain(name='other_domain')
cls.other_domain.save()
cls.ccuser_1 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_2 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_other_domain = CommCareUser.create(
domain=cls.other_domain.name,
username='******',
password='******',
email='*****@*****.**',
)
def test_sync_log(self):
from casexml.apps.phone.models import SyncLog, SimplifiedSyncLog
from corehq.apps.users.models import WebUser, CommCareUser
from casexml.apps.phone.models import get_sync_log_class_by_format
web_user = WebUser.create(
domain=self.domain_name,
username='******',
password='******',
email='*****@*****.**',
)
mobile_user = CommCareUser.create(
self.domain_name, 'mobile_user1', 'secret'
)
other_user = CommCareUser.create(
'other_domain', 'mobile_user2', 'secret'
)
self.addCleanup(other_user.delete)
l1 = SyncLog(user_id=web_user._id)
l1.save()
l2 = SimplifiedSyncLog(user_id=mobile_user._id)
l2.save()
other_log = SyncLog(user_id=other_user._id)
other_log.save()
def _synclog_to_class(doc):
if doc['doc_type'] == 'SyncLog':
return get_sync_log_class_by_format(doc.get('log_format'))
expected_docs = [web_user, mobile_user, l1, l2]
not_expected_docs = [other_user, other_log]
self._dump_and_load(expected_docs, not_expected_docs, doc_to_doc_class=_synclog_to_class)
def setUpClass(cls):
super(MessageLogReportTest, cls).setUpClass()
cls.domain_obj = create_domain(cls.domain)
cls.factory = RequestFactory()
cls.couch_user = WebUser.create(None, "phone_report_test", "foobar")
cls.couch_user.add_domain_membership(cls.domain, is_admin=True)
cls.couch_user.save()
def test_get_list(self):
response = self._assert_auth_get_resource(self.list_endpoint)
self.assertEqual(response.status_code, 200)
api_users = json.loads(response.content)['objects']
self.assertEqual(len(api_users), 1)
self._check_user_data(self.user, api_users[0])
another_user = WebUser.create(self.domain.name, 'anotherguy', '***')
another_user.set_role(self.domain.name, 'field-implementer')
another_user.save()
self.addCleanup(another_user.delete)
response = self._assert_auth_get_resource(self.list_endpoint)
self.assertEqual(response.status_code, 200)
api_users = json.loads(response.content)['objects']
self.assertEqual(len(api_users), 2)
# username filter
response = self._assert_auth_get_resource('%s?web_username=%s' % (self.list_endpoint, 'anotherguy'))
self.assertEqual(response.status_code, 200)
api_users = json.loads(response.content)['objects']
self.assertEqual(len(api_users), 1)
self._check_user_data(another_user, api_users[0])
response = self._assert_auth_get_resource('%s?web_username=%s' % (self.list_endpoint, 'nomatch'))
self.assertEqual(response.status_code, 200)
api_users = json.loads(response.content)['objects']
self.assertEqual(len(api_users), 0)
def setUp(self):
self.domain_name = 'test'
self.password = "******"
username = "******"
email = "*****@*****.**"
self.client = Client()
self.user = WebUser.create(self.domain_name, username, self.password, email, is_admin=True)
self.url = '/a/{}/data/edit/archive_forms/'.format(self.domain_name)
django_user = self.user.get_django_user()
try:
self.user_role = UserRole.objects.get(user=django_user)
except UserRole.DoesNotExist:
user_privs = Role.objects.get_or_create(
name="Privileges for %s" % django_user.username,
slug="%s_privileges" % django_user.username,
)[0]
self.user_role = UserRole.objects.create(
user=django_user,
role=user_privs,
)
# Setup default roles and plans
generator.instantiate_accounting_for_tests()
self.bulk_role = Role.objects.filter(slug=privileges.BULK_CASE_MANAGEMENT)[0]
Grant.objects.create(from_role=self.user_role.role, to_role=self.bulk_role)
Role.get_cache().clear()
self.client.login(username=self.user.username, password=self.password)
toggles.BULK_ARCHIVE_FORMS.set(self.user.username, True)
def test_project_admin_can_edit_anything(self):
project_admin = WebUser.create(self.domain, 'kennedy', 'password')
project_admin.get_domain_membership(self.domain).is_admin = True
project_admin.save()
self.assertCanEdit(project_admin, self.cambridge_form)
self.assertCanEdit(project_admin, self.boston_form)
def handle(self, username, **options):
from corehq.apps.users.models import WebUser
try:
validate_email(username)
except EmailSyntaxError:
raise CommandError('Your username must be an email address')
couch_user = WebUser.get_by_username(username)
if couch_user:
if not isinstance(couch_user, WebUser):
raise CommandError('Username already in use by a non-web user')
print("✓ User {} exists".format(couch_user.username))
else:
password = self.get_password_from_user()
couch_user = WebUser.create(None, username, password)
print("→ User {} created".format(couch_user.username))
is_superuser_changed = not couch_user.is_superuser
is_staff_changed = not couch_user.is_staff
couch_user.is_superuser = True
couch_user.is_staff = True
if is_superuser_changed or is_staff_changed:
couch_user.save()
if is_superuser_changed:
print("→ User {} is now a superuser".format(couch_user.username))
else:
print("✓ User {} is a superuser".format(couch_user.username))
if is_staff_changed:
print("→ User {} can now access django admin".format(couch_user.username))
else:
print("✓ User {} can access django admin".format(couch_user.username))
def setUp(self):
self.client = Client()
self.domain = Domain(name="fandago", is_active=True)
self.domain.save()
toggles.TRANSFER_DOMAIN.set("domain:{domain}".format(domain=self.domain.name), True)
self.username = '******'
self.password = '******'
self.user = WebUser.create(self.domain.name, self.username, self.password)
self.user.set_role(self.domain.name, 'admin')
self.user.save()
self.mugglename = 'muggle'
self.muggle = WebUser.create('anotherdomain', self.mugglename, self.password)
self.muggle.save()
def arbitrary_web_user(save=True, is_dimagi=False):
domain = data_gen.arbitrary_unique_name().lower()[:25]
username = "******" % (data_gen.arbitrary_username(), 'dimagi' if is_dimagi else 'gmail')
web_user = WebUser.create(domain, username, 'test123')
if save:
web_user.save()
return web_user
def test_get_list(self):
self.client.login(username=self.username, password=self.password)
response = self.client.get(self.list_endpoint)
self.assertEqual(response.status_code, 200)
api_users = simplejson.loads(response.content)['objects']
self.assertEqual(len(api_users), 1)
self._check_user_data(self.user, api_users[0])
another_user = WebUser.create(self.domain.name, 'anotherguy', '***')
another_user.set_role(self.domain.name, 'field-implementer')
another_user.save()
response = self.client.get(self.list_endpoint)
self.assertEqual(response.status_code, 200)
api_users = simplejson.loads(response.content)['objects']
self.assertEqual(len(api_users), 2)
# username filter
response = self.client.get('%s?username=%s' % (self.list_endpoint, 'anotherguy'))
self.assertEqual(response.status_code, 200)
api_users = simplejson.loads(response.content)['objects']
self.assertEqual(len(api_users), 1)
self._check_user_data(another_user, api_users[0])
response = self.client.get('%s?username=%s' % (self.list_endpoint, 'nomatch'))
self.assertEqual(response.status_code, 200)
api_users = simplejson.loads(response.content)['objects']
self.assertEqual(len(api_users), 0)
def setUp(self):
self.domain = Domain.get_or_create_with_name("qwerty", is_active=True)
self.username = "******"
self.password = "******"
self.user = WebUser.create(self.domain.name, self.username, self.password)
self.user.set_role(self.domain.name, "admin")
self.user.save()
def setUp(self):
super(TestTreeValidator, self).setUp()
self.domain_obj = create_domain(self.domain)
self.user = WebUser.create(self.domain, 'username', 'password')
def setUp(self):
super(TestLocationFilter, self).setUp()
self.web_user = WebUser.create(self.domain, 'test', 'test')
def setup_webuser(cls, username, domain, role):
user = WebUser.create(domain.name, username,
'{}-password'.format(username), None, None)
user.set_role(domain.name, role)
user.save()
return user
def setUp(self):
self.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
self.username = '******'
self.password = '******'
self.user = WebUser.create(self.domain.name, self.username, self.password, None, None)
def make_web_user(cls, location):
username = ''.join(random.sample(string.ascii_letters, 8))
user = WebUser.create(cls.domain, username, 'password')
user.set_location(cls.domain, cls.locations[location])
return user
def setUp(self):
super(ReportCacheTest, self).setUp()
self.test_domain = create_domain(self.domain)
self.web_user1 = WebUser.create(self.domain, 'w1', 'secret')
self.web_user2 = WebUser.create(self.domain, 'w2', 'secret')
def setUpClass(cls):
super(AllCommCareUsersTest, cls).setUpClass()
delete_all_users()
hard_delete_deleted_users()
cls.ccdomain = Domain(name='cc_user_domain')
cls.ccdomain.save()
cls.other_domain = Domain(name='other_domain')
cls.other_domain.save()
bootstrap_location_types(cls.ccdomain.name)
initialize_domain_with_default_roles(cls.ccdomain.name)
cls.user_roles = UserRole.objects.get_by_domain(cls.ccdomain.name)
cls.custom_role = UserRole.create(cls.ccdomain.name, "Custom Role")
cls.loc1 = make_loc('spain', domain=cls.ccdomain.name, type="district")
cls.loc2 = make_loc('madagascar',
domain=cls.ccdomain.name,
type="district")
cls.ccuser_1 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.ccuser_1.set_location(cls.loc1)
cls.ccuser_1.save()
cls.ccuser_2 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.ccuser_2.set_role(cls.ccdomain.name,
cls.custom_role.get_qualified_id())
cls.ccuser_2.set_location(cls.loc2)
cls.ccuser_2.save()
cls.web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.location_restricted_web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.location_restricted_web_user.add_to_assigned_locations(
domain=cls.ccdomain.name, location=cls.loc2)
cls.ccuser_other_domain = CommCareUser.create(
domain=cls.other_domain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.retired_user = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.retired_user.retire(cls.ccdomain.name, deleted_by=None)
cls.ccuser_inactive = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.ccuser_inactive.is_active = False
cls.ccuser_inactive.save()
cls.ccuser_inactive.set_location(cls.loc2)
def setUpClass(cls):
super(AllCommCareUsersTest, cls).setUpClass()
delete_all_users()
hard_delete_deleted_users()
cls.ccdomain = Domain(name='cc_user_domain')
cls.ccdomain.save()
cls.other_domain = Domain(name='other_domain')
cls.other_domain.save()
bootstrap_location_types(cls.ccdomain.name)
UserRole.init_domain_with_presets(cls.ccdomain.name)
cls.user_roles = UserRole.by_domain(cls.ccdomain.name)
cls.custom_role = UserRole.get_or_create_with_permissions(
cls.ccdomain.name,
Permissions(
edit_apps=True,
edit_web_users=True,
view_web_users=True,
view_roles=True,
), "Custom Role")
cls.custom_role.save()
cls.loc1 = make_loc('spain', domain=cls.ccdomain.name, type="district")
cls.loc2 = make_loc('madagascar',
domain=cls.ccdomain.name,
type="district")
cls.ccuser_1 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_1.set_location(cls.loc1)
cls.ccuser_1.save()
cls.ccuser_2 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_2.set_role(cls.ccdomain.name,
cls.custom_role.get_qualified_id())
cls.ccuser_2.set_location(cls.loc2)
cls.ccuser_2.save()
cls.web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_other_domain = CommCareUser.create(
domain=cls.other_domain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.retired_user = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.retired_user.retire()
def setUpClass(cls):
super(SchedulingRecipientTest, cls).setUpClass()
cls.domain_obj = create_domain(cls.domain)
cls.location_types = setup_location_types(cls.domain,
['country', 'state', 'city'])
cls.country_location = make_loc('usa',
domain=cls.domain,
type='country')
cls.state_location = make_loc('ma',
domain=cls.domain,
type='state',
parent=cls.country_location)
cls.city_location = make_loc('boston',
domain=cls.domain,
type='city',
parent=cls.state_location)
cls.mobile_user = CommCareUser.create(cls.domain, 'mobile', 'abc',
None, None)
cls.mobile_user.set_location(cls.city_location)
cls.mobile_user2 = CommCareUser.create(cls.domain, 'mobile2', 'abc',
None, None)
cls.mobile_user2.set_location(cls.state_location)
cls.mobile_user3 = CommCareUser.create(cls.domain,
'mobile3',
'abc',
None,
None,
metadata={
'role': 'pharmacist',
})
cls.mobile_user3.save()
cls.mobile_user4 = CommCareUser.create(cls.domain,
'mobile4',
'abc',
None,
None,
metadata={
'role': 'nurse',
})
cls.mobile_user4.save()
cls.mobile_user5 = CommCareUser.create(cls.domain,
'mobile5',
'abc',
None,
None,
metadata={
'role':
['nurse', 'pharmacist'],
})
cls.mobile_user5.save()
full_username = normalize_username('mobile', cls.domain)
cls.full_mobile_user = CommCareUser.create(cls.domain, full_username,
'abc', None, None)
cls.definition = CustomDataFieldsDefinition(
domain=cls.domain, field_type=UserFieldsView.field_type)
cls.definition.save()
cls.definition.set_fields([
Field(
slug='role',
label='Role',
),
])
cls.definition.save()
cls.profile = CustomDataFieldsProfile(
name='nurse_profile',
fields={'role': ['nurse']},
definition=cls.definition,
)
cls.profile.save()
cls.mobile_user6 = CommCareUser.create(cls.domain,
'mobile6',
'abc',
None,
None,
metadata={
PROFILE_SLUG:
cls.profile.id,
})
cls.mobile_user5.save()
cls.web_user = WebUser.create(cls.domain, 'web', 'abc', None, None)
cls.web_user2 = WebUser.create(cls.domain,
'web2',
'abc',
None,
None,
metadata={
'role': 'nurse',
})
cls.web_user2.save()
cls.group = Group(domain=cls.domain, users=[cls.mobile_user.get_id])
cls.group.save()
cls.group2 = Group(domain=cls.domain,
users=[
cls.mobile_user.get_id,
cls.mobile_user3.get_id,
cls.mobile_user4.get_id,
cls.mobile_user5.get_id,
cls.mobile_user6.get_id,
])
cls.group2.save()
cls.case_group = CommCareCaseGroup(domain=cls.domain)
cls.case_group.save()
cls.process_pillow_changes = process_pillow_changes(
'DefaultChangeFeedPillow')
cls.process_pillow_changes.add_pillow(get_case_messaging_sync_pillow())
def create_web_user(self, username, password):
user = WebUser.create(self.domain, username, password, None, None)
self.users.append(user)
return user
def setUpClass(cls):
super(TestLocationAncestorsView, cls).setUpClass()
cls.domain = create_domain('icds-test')
state = LocationType.objects.create(domain=cls.domain.name,
name='state',
parent_type=None)
district = LocationType.objects.create(domain=cls.domain.name,
name='district',
parent_type=state)
block = LocationType.objects.create(domain=cls.domain.name,
name='block',
parent_type=district)
supervisor = LocationType.objects.create(domain=cls.domain.name,
name='supervisor',
parent_type=block)
awc = LocationType.objects.create(domain=cls.domain.name,
name='awc',
parent_type=supervisor)
cls.state = SQLLocation.objects.create(name='Test State',
domain=cls.domain.name,
location_type=state)
cls.district = SQLLocation.objects.create(
name='Test District',
domain=cls.domain.name,
location_type=district,
parent=cls.state,
)
cls.district_2 = SQLLocation.objects.create(
name='Test District 2',
domain=cls.domain.name,
location_type=district,
parent=cls.state,
)
cls.block = SQLLocation.objects.create(name='Test Block',
domain=cls.domain.name,
location_type=block,
parent=cls.district)
cls.block_2 = SQLLocation.objects.create(name='Test Block 2',
domain=cls.domain.name,
location_type=block,
parent=cls.district_2)
cls.supervisor = SQLLocation.objects.create(name='Test Supervisor',
domain=cls.domain.name,
location_type=supervisor,
parent=cls.block)
cls.supervisor_2 = SQLLocation.objects.create(name='Test Supervisor 2',
domain=cls.domain.name,
location_type=supervisor,
parent=cls.block_2)
cls.awc = SQLLocation.objects.create(name='Test AWC',
domain=cls.domain.name,
location_type=awc,
parent=cls.supervisor)
cls.awc_2 = SQLLocation.objects.create(name='Test AWC 2',
domain=cls.domain.name,
location_type=awc,
parent=cls.supervisor_2)
cls.state_2 = SQLLocation.objects.create(name='Test State 2',
domain=cls.domain.name,
location_type=state)
cls.state_3 = SQLLocation.objects.create(name='Test State 3',
domain=cls.domain.name,
location_type=state)
cls.factory = RequestFactory()
cls.user = WebUser.create(cls.domain.name, 'test', 'passwordtest')
cls.user.is_authenticated = True
cls.user.is_superuser = True
cls.user.is_authenticated = True
cls.user.is_active = True
def setUp(self):
self.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
self.username = '******'
self.password = '******'
self.user = WebUser.create(self.domain.name, self.username,
self.password).get_django_user()
def setUpClass(cls):
super(TestDecodePassword, cls).setUpClass()
cls.domain = Domain(name="delhi", is_active=True)
cls.domain.save()
cls.username = "******"
cls.web_user = WebUser.create(cls.domain.name, cls.username, "123456")
def test_web_user_reindexer_v2(self):
username = '******'
WebUser.create(DOMAIN, username, 'secret', None, None)
reindex_and_clean('user')
self._assert_user_in_es(username, is_webuser=True)
def setUpClass(cls):
super().setUpClass()
cls.domain = create_domain(cls.domain_name)
cls.couch_user = WebUser.create(None, "test", "foobar", None, None)
cls.couch_user.add_domain_membership(cls.domain_name, is_admin=True)
cls.couch_user.save()
def create_web_user(self):
# A Couch user is required for logout
user = WebUser.create('', '*****@*****.**', 'mockmock', None, None)
user.save()
self.addCleanup(lambda: user.delete(None))
def setUpClass(cls):
super(DigestOtaRestoreTest, cls).setUpClass()
create_domain(cls.domain)
create_domain(cls.wrong_domain)
cls.commcare_user = CommCareUser.create(cls.domain, cls.username, cls.password)
cls.web_user = WebUser.create(cls.domain, cls.web_username, cls.password)
def setUpClass(cls):
cls.domain = create_domain('adomain')
cls.user = WebUser.create('adomain', 'ben', '***')
def normal_user():
user = WebUser.create(DOMAIN_NAME, USERNAME, PASSWORD)
try:
yield
finally:
user.delete()
def superuser():
user = WebUser.create(DOMAIN_NAME, USERNAME, PASSWORD, is_superuser=True)
try:
yield
finally:
user.delete()
def setUpClass(cls):
super(DropboxUploadHelperTest, cls).setUpClass()
cls.domain = create_domain('adomain')
cls.user = WebUser.create('adomain', 'ben', '***')
def setUp(self):
super(TestBulkManagementNoInitialLocs, self).setUp()
self.domain_obj = create_domain(self.domain)
self.user = WebUser.create(self.domain, 'username', 'password', None, None)
def setUp(self):
super(TestBulkManagementWithInitialLocs, self).setUp()
self.user = WebUser.create(self.domain, 'username', 'password')
def setUp(self):
create_domain(self.domain)
self.web_user1 = WebUser.create(self.domain, 'w1', 'secret')
self.web_user2 = WebUser.create(self.domain, 'w2', 'secret')
def setUpClass(cls):
super(ReportTestCase, cls).setUpClass()
cls.domain = create_domain('test-domain')
cls.web_user = WebUser.get_by_username('test')
if not cls.web_user:
cls.web_user = WebUser.create('test-domain', 'test', 'test', None,
None)
SQLProduct.objects.create(domain=cls.domain.name,
name='Product 2',
code='p2',
product_id='p2')
SQLProduct.objects.create(domain=cls.domain.name,
name='Product 3',
code='p3',
product_id='p3')
SQLProduct.objects.create(domain=cls.domain.name,
name='Product 1',
code='p1',
product_id='p1')
region_location_type = LocationType.objects.create(
domain=cls.domain.name,
name='Region',
)
SQLLocation.objects.create(domain=cls.domain.name,
name='Region 1',
location_id='r1',
location_type=region_location_type)
district_location_type = LocationType.objects.create(
domain=cls.domain.name,
name='District',
)
SQLLocation.objects.create(domain=cls.domain.name,
name='District 1',
location_id='d1',
location_type=district_location_type)
cls.engine = connection_manager.get_engine(DEFAULT_ENGINE_ID)
cls.intra_table = IntraHealthFluff._table
cls.couverture_table = CouvertureFluff._table
cls.taux_table = TauxDeRuptureFluff._table
cls.taux_de_satisfaction_table = TauxDeSatisfactionFluff._table
cls.livraison_table = LivraisonFluff._table
cls.recouvrement_table = RecouvrementFluff._table
with cls.engine.begin() as connection:
cls.couverture_table.create(connection, checkfirst=True)
cls.intra_table.create(connection, checkfirst=True)
cls.taux_table.create(connection, checkfirst=True)
cls.taux_de_satisfaction_table.create(connection, checkfirst=True)
cls.recouvrement_table.create(connection, checkfirst=True)
cls.livraison_table.create(connection, checkfirst=True)
insert = cls.intra_table.insert().values([
dict(doc_id='1',
date=datetime(2017, 11, 17),
product_name='Product 1',
product_id='p1',
district_id='d1',
district_name='District 1',
location_id='pps1',
region_id='r1',
PPS_name='PPS 1',
actual_consumption_total=10,
billed_consumption_total=5,
stock_total=33,
total_stock_total=70,
quantity_total=13,
cmm_total=16),
dict(doc_id='1',
date=datetime(2017, 11, 17),
product_name='Product 2',
product_id='p2',
district_id='d1',
district_name='District 1',
location_id='pps1',
region_id='r1',
PPS_name='PPS 1',
actual_consumption_total=2,
billed_consumption_total=2,
stock_total=1,
total_stock_total=2,
quantity_total=3,
cmm_total=4),
dict(doc_id='1',
date=datetime(2017, 11, 17),
product_name='Product 3',
product_id='p3',
district_id='d1',
district_name='District 1',
location_id='pps1',
region_id='r1',
PPS_name='PPS 1',
actual_consumption_total=6,
billed_consumption_total=4,
stock_total=14,
total_stock_total=0,
quantity_total=88,
cmm_total=99),
dict(doc_id='2',
date=datetime(2017, 11, 17),
product_name='Product 1',
product_id='p1',
district_id='d1',
district_name='District 1',
location_id='pps2',
region_id='r1',
PPS_name='PPS 2',
actual_consumption_total=13,
billed_consumption_total=11,
stock_total=50,
total_stock_total=100,
quantity_total=1,
cmm_total=8),
dict(doc_id='2',
date=datetime(2017, 11, 17),
product_name='Product 2',
product_id='p2',
district_id='d1',
district_name='District 1',
location_id='pps2',
region_id='r1',
PPS_name='PPS 2',
actual_consumption_total=0,
billed_consumption_total=0,
stock_total=2,
total_stock_total=17,
quantity_total=3,
cmm_total=15),
dict(doc_id='2',
date=datetime(2017, 11, 17),
product_name='Product 3',
product_id='p3',
district_id='d1',
district_name='District 1',
location_id='pps2',
region_id='r1',
PPS_name='PPS 2',
actual_consumption_total=150,
billed_consumption_total=11,
stock_total=4,
total_stock_total=0,
quantity_total=11,
cmm_total=12)
])
connection.execute(insert)
def setUpClass(cls):
super().setUpClass()
cls.user = WebUser.create(cls.domain, 'fiona', 'secret', None, None)
def _setup_web_user(cls):
cls.web_user = WebUser.create(cls.DOMAIN_NAME, cls.WEB_USER, '*****')
cls.web_user.save()
cls.request.couch_user = cls.web_user
def setUp(self):
super(GuidedTourTest, self).setUp()
self.web_user = WebUser.create(self.domain, '*****@*****.**',
'test123')
self.test_user = User.objects.get_by_natural_key(
self.web_user.username)
def setUp(self):
super(TestRestrictedUserUpload, self).setUp()
self.user = WebUser.create(self.domain, 'username', 'password')
self.user.set_location(self.domain, self.locations['Middlesex'])
restrict_user_by_location(self.domain, self.user)
def test_web_user_reindexer_v2(self):
username = '******'
WebUser.create(DOMAIN, username, 'secret')
call_command('ptop_reindexer_v2', 'user', cleanup=True, noinput=True)
self._assert_user_in_es(username, is_webuser=True)
