def setUpClass(cls):
clear_domain_names(cls.domain, 'nodomain')
super(TestDomainMemberships, cls).setUpClass()
w_username = "******"
w_email = "*****@*****.**"
w2_username = "******"
w2_email = "*****@*****.**"
cc_username = "******"
password = "******"
cls.project = Domain(name=cls.domain)
cls.project.save()
create_domain('nodomain')
cls.webuser = WebUser.create(cls.domain,
w_username,
password,
None,
None,
email=w_email)
cls.webuser2 = WebUser.create('nodomain',
w2_username,
password,
None,
None,
email=w2_email)
cls.ccuser = CommCareUser.create(cls.domain, cc_username, password,
None, None)
initialize_domain_with_default_roles(cls.domain)
role = UserRole.objects.get(domain=cls.domain,
name=UserRolePresets.FIELD_IMPLEMENTER)
cls.field_implementer_role_id = role.get_qualified_id()
def test_reset_initial_roles_for_domain(self):
self.addCleanup(self._delete_presets)
initialize_domain_with_default_roles(self.domain)
role = UserRole.objects.get(domain=self.domain, name=UserRolePresets.APP_EDITOR)
original_permissions = role.permissions
role.set_permissions([])
self.assertEqual(role.permissions.to_list(), [])
reset_initial_roles_for_domain(self.domain)
self.assertEqual(role.permissions, original_permissions)
def test_unarchive_roles_for_domain(self):
self.addCleanup(self._delete_presets)
initialize_domain_with_default_roles(self.domain)
for role in UserRole.objects.get_by_domain(self.domain):
role.is_archived = True
role.save()
unarchived_role_count = len(UserRole.objects.get_by_domain(self.domain, include_archived=False))
self.assertEqual(unarchived_role_count, 0)
unarchive_roles_for_domain(self.domain)
unarchived_role_count = len(UserRole.objects.get_by_domain(self.domain, include_archived=False))
self.assertEqual(unarchived_role_count, 5)
def setUp(self):
super(TestUserRoleSubscriptionChanges, self).setUp()
self.domain = Domain(
name="test-sub-changes",
is_active=True,
)
self.domain.save()
self.other_domain = Domain(
name="other-domain",
is_active=True,
)
self.other_domain.save()
initialize_domain_with_default_roles(self.domain.name)
self.user_roles = UserRole.objects.get_by_domain(self.domain.name)
self.custom_role = UserRole.create(
self.domain.name,
"Custom Role",
permissions=Permissions(
edit_apps=True,
view_apps=True,
edit_web_users=True,
view_web_users=True,
view_roles=True,
)
)
self.admin_username = generator.create_arbitrary_web_user_name()
self.web_users = []
self.commcare_users = []
for role in [self.custom_role] + self.user_roles:
web_user = WebUser.create(
self.other_domain.name, generator.create_arbitrary_web_user_name(), 'test123', None, None
)
web_user.is_active = True
web_user.add_domain_membership(self.domain.name, role_id=role.get_id)
web_user.save()
self.web_users.append(web_user)
commcare_user = generator.arbitrary_commcare_user(
domain=self.domain.name)
commcare_user.set_role(self.domain.name, role.get_qualified_id())
commcare_user.save()
self.commcare_users.append(commcare_user)
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.admin_username)[0]
self.advanced_plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
def test_archive_custom_roles_for_domain(self):
def _unarchive_custom_role():
self.role1.is_archived = False
self.role1.save()
self.addCleanup(self._delete_presets)
self.addCleanup(_unarchive_custom_role)
initialize_domain_with_default_roles(self.domain)
roles = UserRole.objects.get_by_domain(self.domain, include_archived=True)
self.assertEqual(len(roles), 5)
archive_custom_roles_for_domain(self.domain)
roles = UserRole.objects.get_by_domain(self.domain, include_archived=False)
self.assertEqual(len(roles), 4)
def request_new_domain(request,
project_name,
is_new_user=True,
is_new_sso_user=False):
now = datetime.utcnow()
current_user = CouchUser.from_django_user(request.user, strict=True)
dom_req = RegistrationRequest()
if is_new_user:
dom_req.request_time = now
dom_req.request_ip = get_ip(request)
dom_req.activation_guid = uuid.uuid1().hex
name = name_to_url(project_name, "project")
with CriticalSection(['request_domain_name_{}'.format(name)]):
name = Domain.generate_name(name)
new_domain = Domain(name=name,
hr_name=project_name,
is_active=False,
date_created=datetime.utcnow(),
creating_user=current_user.username,
secure_submissions=True,
first_domain_for_user=is_new_user)
# Avoid projects created by dimagi.com staff members as self started
new_domain.internal.self_started = not current_user.is_dimagi
if not is_new_user or is_new_sso_user:
new_domain.is_active = True
# ensure no duplicate domain documents get created on cloudant
new_domain.save(**get_safe_write_kwargs())
if not new_domain.name:
new_domain.name = new_domain._id
new_domain.save() # we need to get the name from the _id
dom_req.domain = new_domain.name
if not settings.ENTERPRISE_MODE:
_setup_subscription(new_domain.name, current_user)
initialize_domain_with_default_roles(new_domain.name)
if request.user.is_authenticated:
if not current_user:
current_user = WebUser()
current_user.sync_from_django_user(request.user)
current_user.save()
current_user.add_domain_membership(new_domain.name, is_admin=True)
current_user.save()
dom_req.requesting_user_username = request.user.username
dom_req.new_user_username = request.user.username
elif is_new_user:
_soft_assert_registration_issues(
f"A new user {request.user.username} was not added to their domain "
f"{new_domain.name} during registration")
if is_new_user and not is_new_sso_user:
dom_req.save()
if settings.IS_SAAS_ENVIRONMENT:
# Load template apps to the user's new domain in parallel
from corehq.apps.app_manager.tasks import load_appcues_template_app
header = [
load_appcues_template_app.si(new_domain.name,
current_user.username, slug)
for slug in APPCUES_APP_SLUGS
]
callback = send_domain_registration_email.si(
request.user.email, dom_req.domain, dom_req.activation_guid,
request.user.get_full_name(), request.user.first_name)
chord(header)(callback)
else:
send_domain_registration_email(request.user.email, dom_req.domain,
dom_req.activation_guid,
request.user.get_full_name(),
request.user.first_name)
send_new_request_update_email(request.user,
get_ip(request),
new_domain.name,
is_new_user=is_new_user,
is_new_sso_user=is_new_sso_user)
send_hubspot_form(HUBSPOT_CREATED_NEW_PROJECT_SPACE_FORM_ID, request)
return new_domain.name
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 test_get_custom_roles_for_domain(self):
self.addCleanup(self._delete_presets)
initialize_domain_with_default_roles(self.domain)
roles = get_custom_roles_for_domain(self.domain)
self.assertEqual([role.name for role in roles], ["role1"])
def test_init_domain_with_presets(self):
self.addCleanup(self._delete_presets)
initialize_domain_with_default_roles(self.domain)
role_names = set(UserRole.objects.filter(domain=self.domain).values_list("name", flat=True))
self.assertEqual(role_names, set(UserRolePresets.INITIAL_ROLES) | {'role1'})
def setUpClass(cls):
super().setUpClass()
initialize_domain_with_default_roles(cls.domain.name)
