def test_class(self): self.assertEqual('state', DomainPermissionsMirror.source_domain('county')) self.assertIsNone(DomainPermissionsMirror.source_domain('state')) self.assertEqual(['county'], DomainPermissionsMirror.mirror_domains('state')) self.assertEqual([], DomainPermissionsMirror.mirror_domains('county'))
def test_multi_domain(self): dm = DomainPermissionsMirror(source=self.domain.name, mirror=self.other_domain.name) dm.save() import_users_and_groups( self.domain.name, [self._get_spec(username=123, domain=self.other_domain.name)], [], self.uploading_user, mock.MagicMock()) self.assertIsNotNone( CommCareUser.get_by_username('{}@{}.commcarehq.org'.format( '123', self.other_domain.name)))
def __init__(self, *args, **kwargs): from corehq.apps.locations.forms import LocationSelectWidget from corehq.apps.users.views import get_editable_role_choices self.domain = kwargs.pop('domain') self.couch_user = kwargs.pop('couch_user') super(CommCareUserFilterForm, self).__init__(*args, **kwargs) self.fields['location_id'].widget = LocationSelectWidget(self.domain) self.fields['location_id'].help_text = ExpandedMobileWorkerFilter.location_search_help if is_icds_cas_project(self.domain) and not self.couch_user.is_domain_admin(self.domain): roles = get_editable_role_choices(self.domain, self.couch_user, allow_admin_role=True, use_qualified_id=False) self.fields['role_id'].choices = roles else: roles = UserRole.by_domain(self.domain) self.fields['role_id'].choices = [('', _('All Roles'))] + [ (role._id, role.name or _('(No Name)')) for role in roles] self.fields['domains'].choices = [(self.domain, self.domain)] if len(DomainPermissionsMirror.mirror_domains(self.domain)) > 0: self.fields['domains'].choices = [('all_project_spaces', _('All Project Spaces'))] + \ [(self.domain, self.domain)] + \ [(domain, domain) for domain in DomainPermissionsMirror.mirror_domains(self.domain)] self.helper = FormHelper() self.helper.form_method = 'GET' self.helper.form_id = 'user-filters' self.helper.form_class = 'form-horizontal' self.helper.form_action = reverse('download_commcare_users', args=[self.domain]) self.helper.label_class = 'col-sm-3 col-md-2' self.helper.field_class = 'col-sm-9 col-md-8 col-lg-6' self.helper.form_text_inline = True self.helper.layout = crispy.Layout( crispy.Fieldset( _("Filter and Download Users"), crispy.Field('role_id', css_class="hqwebapp-select2"), crispy.Field('search_string'), crispy.Field('location_id'), crispy.Field('columns'), crispy.Field('domains'), ), hqcrispy.FormActions( twbscrispy.StrictButton( _("Download All Users"), type="submit", css_class="btn btn-primary submit_button", ) ), )
def validate_spec(self, spec): target_domain = spec.get('domain') if target_domain and target_domain != self.domain: mirror_domains = DomainPermissionsMirror.mirror_domains( self.domain) if target_domain not in mirror_domains: return self.error_message.format(target_domain, self.domain)
def test_multi_domain(self): self.setup_users() dm = DomainPermissionsMirror(source=self.domain.name, mirror=self.other_domain.name) dm.save() import_users_and_groups(self.domain.name, [ self._get_spec(username='******', domain=self.other_domain.name, role=self.other_domain_role.name, email='*****@*****.**') ], [], self.uploading_user, mock.MagicMock(), True) self.assertIsNotNone( Invitation.objects.filter(email='*****@*****.**').first()) self.assertEqual( Invitation.objects.filter(email='*****@*****.**').first().domain, self.other_domain.name)
def setUpClass(cls): super().setUpClass() # Set up domains cls.mirror = DomainPermissionsMirror(source='state', mirror='county') cls.mirror.save() create_domain('state') create_domain('county') # Set up users cls.web_user_admin = WebUser.create('state', 'emma', 'badpassword', None, None, email='*****@*****.**', is_admin=True) cls.web_user_non_admin = WebUser.create('state', 'clementine', 'worsepassword', None, None, email='*****@*****.**') cls.api_key, _ = HQApiKey.objects.get_or_create( user=WebUser.get_django_user(cls.web_user_non_admin))
def do_import(spreadsheet, config, domain, task=None, record_form_callback=None): has_domain_column = 'domain' in [c.lower() for c in spreadsheet.get_header_columns()] if has_domain_column and DOMAIN_PERMISSIONS_MIRROR.enabled(domain): mirror_domains = DomainPermissionsMirror.mirror_domains(domain) sub_domains = set() import_results = _ImportResults() for row_num, row in enumerate(spreadsheet.iter_row_dicts(), start=1): if row_num == 1: continue # skip first row (header row) sheet_domain = row.get('domain') if sheet_domain != domain and sheet_domain not in mirror_domains: err = exceptions.CaseRowError(column_name='domain') err.title = _('Invalid domain') err.message = _('Following rows contain invalid value for domain column.') import_results.add_error(row_num, err) else: sub_domains.add(sheet_domain) for sub_domain in sub_domains: importer = _TimedAndThrottledImporter( sub_domain, config, task, record_form_callback, import_results, multi_domain=True ) importer.do_import(spreadsheet) return import_results.to_json() else: importer = _TimedAndThrottledImporter(domain, config, task, record_form_callback, multi_domain=False) return importer.do_import(spreadsheet)
def domain(domain, allow_mirroring=False): domains = [domain] if allow_mirroring: from corehq.apps.users.models import DomainPermissionsMirror source_domain = DomainPermissionsMirror.source_domain(domain) if source_domain: domains.append(source_domain) return filters.OR(filters.term("domain.exact", domains), filters.term("domain_memberships.domain.exact", domains))
def clean_domains(self): if 'domains' in self.data: domains = self.data.getlist('domains') else: domains = self.data.getlist('domains[]', [self.domain]) if 'all_project_spaces' in domains: domains = DomainPermissionsMirror.mirror_domains(self.domain) domains += [self.domain] return domains
def test_multiple_domain_case_import(self): mirror_domain1 = DomainPermissionsMirror(source=self.domain, mirror='mirrordomain1') mirror_domain2 = DomainPermissionsMirror(source=self.domain, mirror='mirrordomain2') mirror_domain1.save() mirror_domain2.save() headers_with_domain = ['case_id', 'name', 'artist', 'domain'] config_1 = self._config(headers_with_domain, create_new_cases=True, search_column='case_id') case_with_domain_file = make_worksheet_wrapper( ['case_id', 'name', 'artist', 'domain'], ['', 'name-0', 'artist-0', self.domain], ['', 'name-1', 'artist-1', mirror_domain1.mirror], ['', 'name-2', 'artist-2', mirror_domain2.mirror], ['', 'name-3', 'artist-3', self.domain], ['', 'name-4', 'artist-4', self.domain], ['', 'name-5', 'artist-5', 'not-existing-domain']) res = do_import(case_with_domain_file, config_1, self.domain) self.assertEqual(5, res['created_count']) self.assertEqual(0, res['match_count']) self.assertEqual(1, res['failed_count']) # Asserting current domain cur_case_ids = self.accessor.get_case_ids_in_domain() cur_cases = list(self.accessor.get_cases(cur_case_ids)) self.assertEqual(3, len(cur_cases)) #Asserting current domain case property cases = {c.name: c for c in cur_cases} self.assertEqual(cases['name-0'].get_case_property('artist'), 'artist-0') # Asserting mirror domain 1 md1_case_ids = CaseAccessors( mirror_domain1.mirror).get_case_ids_in_domain() md1_cases = list(self.accessor.get_cases(md1_case_ids)) self.assertEqual(1, len(md1_cases)) # Asserting mirror domain 1 case property md1_cases_pro = {c.name: c for c in md1_cases} self.assertEqual(md1_cases_pro['name-1'].get_case_property('artist'), 'artist-1') # Asserting mirror domain 2 md2_case_ids = CaseAccessors( mirror_domain2.mirror).get_case_ids_in_domain() md2_cases = list(self.accessor.get_cases(md2_case_ids)) self.assertEqual(1, len(md2_cases)) # Asserting mirror domain 2 case propperty md2_cases_pro = {c.name: c for c in md2_cases} self.assertEqual(md2_cases_pro['name-2'].get_case_property('artist'), 'artist-2')
def get_mirror_domain_links_for_dropdown(couch_user, view_name="domain_homepage"): # Returns dicts with keys 'name', 'display_name', and 'url' from corehq.apps.users.models import DomainPermissionsMirror domain_links_by_name = {d['name']: d for d in get_domain_links_for_dropdown(couch_user)} mirror_domain_objects_by_name = {} for domain_name in domain_links_by_name: for mirror_domain in DomainPermissionsMirror.mirror_domains(domain_name): if mirror_domain not in domain_links_by_name: mirror_domain_objects_by_name[mirror_domain] = Domain.get_by_name(mirror_domain) return _domains_to_links(mirror_domain_objects_by_name.values(), view_name)
def post(self, request, *args, **kwargs): try: data = json.loads(request.body.decode('utf-8')) except ValueError: return HttpResponseBadRequest() if not data or not isinstance(data, dict): return HttpResponseBadRequest() session_id = data.get('sessionId', None) if not session_id: return HttpResponseBadRequest() session = get_session(session_id) user = get_django_user_from_session(session) if user: couch_user = CouchUser.get_by_username(user.username) if not couch_user: raise Http404 else: raise Http404 domain = data.get('domain') if domain and DISABLE_WEB_APPS.enabled(domain): return HttpResponse('Service Temporarily Unavailable', content_type='text/plain', status=503) # reset the session's expiry if there's some formplayer activity secure_session = session.get('secure_session') TimeoutMiddleware.update_secure_session(session, secure_session, couch_user, domain=data.get('domain')) session.save() domains = set() for domain in couch_user.domains: domains.add(domain) mirror_domains = DomainPermissionsMirror.mirror_domains(domain) domains.update(mirror_domains) return JsonResponse({ 'username': user.username, 'djangoUserId': user.pk, 'superUser': user.is_superuser, 'authToken': None, 'domains': list(domains), 'anonymous': False })
def _user_requires_secure_session(couch_user): if not couch_user: return False domains = couch_user.get_domains() if any(Domain.is_secure_session_required(domain) for domain in domains): return True from corehq.apps.users.models import DomainPermissionsMirror for domain in domains: mirrors = DomainPermissionsMirror.mirror_domains(domain) if any(Domain.is_secure_session_required(m) for m in mirrors): return True return False
def setUpClass(cls): super().setUpClass() # Set up domains cls.mirror = DomainPermissionsMirror(source='state', mirror='county') cls.mirror.save() create_domain('state') create_domain('county') # Set up users cls.web_user_admin = WebUser.create('state', 'emma', 'badpassword', '*****@*****.**', is_admin=True) cls.web_user_non_admin = WebUser.create('state', 'clementine', 'worsepassword', '*****@*****.**')
def _get_relevant_domains(cls, couch_user, domain=None): domains = [] # Include current domain, which user may not be a member of if domain: domains.append(domain) if not couch_user: return domains domains.extend(couch_user.get_domains()) from corehq.apps.users.models import DomainPermissionsMirror for domain in domains: domains.extend(DomainPermissionsMirror.mirror_domains(domain)) return domains
def test_domain_allow_mirroring(self): source_domain = self.domain + "-source" mirror = DomainPermissionsMirror(source=source_domain, mirror=self.domain) mirror.save() self._send_user_to_es() self.assertEqual(['superman'], UserES().domain(self.domain).values_list('username', flat=True)) self.assertEqual([], UserES().domain(source_domain).values_list('username', flat=True)) self.assertEqual( ['superman'], UserES().domain(self.domain, allow_mirroring=True).values_list('username', flat=True) ) mirror.delete()
def setUpClass(cls): super().setUpClass() delete_all_users() # Set up domains cls.domain = create_domain('test') cls.mirror_domain = create_domain('mirror') cls.mirror = DomainPermissionsMirror(source=cls.domain.name, mirror=cls.mirror_domain.name) cls.mirror.save() # Set up user cls.web_user = WebUser.create( domain='test', username='******', password='******', created_by=None, created_via=None, ) cls.today = datetime.today().date() cls.last_week = cls.today - timedelta(days=7)
def page_context(self): return { 'mirrors': DomainPermissionsMirror.mirror_domains(self.domain), }