def test_user_query(self): json_output = { "query": { "filtered": { "filter": { "and": [ { "term": { "is_active": True } }, { "term": { "base_doc": "couchuser" } }, ] }, "query": { "match_all": {} } } }, "size": SIZE_LIMIT } query = users.UserES() self.checkQuery(query, json_output)
def get_user_ids_for_user_types(self, admin, unknown, demo, commtrack): """ referenced from CaseListMixin to fetch user_ids for selected user type :param admin: if admin users to be included :param unknown: if unknown users to be included :param demo: if demo users to be included :param commtrack: if commtrack users to be included :return: user_ids for selected user types """ from corehq.apps.es import filters, users as user_es if not any([admin, unknown, demo]): return [] user_filters = [filter_ for include, filter_ in [ (admin, user_es.admin_users()), (unknown, filters.OR(user_es.unknown_users(), user_es.web_users())), (demo, user_es.demo_users()), ] if include] query = (user_es.UserES() .domain(self.domain_object.name) .OR(*user_filters) .show_inactive() .fields([])) user_ids = query.run().doc_ids if commtrack: user_ids.append("commtrack-system") if demo: user_ids.append("demo_user_group_id") user_ids.append("demo_user") return user_ids
def test_users_at_locations(self): location_ids = [ '09d1a58cb849e53bb3a456a5957d998a', '09d1a58cb849e53bb3a456a5957d99ba' ] query = users.UserES().location(location_ids) self._check_user_location_query(query, location_ids)
def test_remove_all_defaults(self): # Elasticsearch fails if you pass it an empty list of filters query = (users.UserES() .remove_default_filter('not_deleted') .remove_default_filter('active')) filters = query.raw_query['query']['filtered']['filter']['and'] self.assertTrue(len(filters) > 0)
def user_es_query(cls, domain, request): user_ids = cls.selected_user_ids(request) user_types = cls.selected_user_types(request) group_ids = cls.selected_group_ids(request) user_type_filters = [] if HQUserType.ADMIN in user_types: user_type_filters.append(user_es.admin_users()) if HQUserType.UNKNOWN in user_types: user_type_filters.append(user_es.unknown_users()) user_type_filters.append(user_es.web_users()) if HQUserType.DEMO_USER in user_types: user_type_filters.append(user_es.demo_users()) q = user_es.UserES().domain(domain) if HQUserType.REGISTERED in user_types: # return all users with selected user_types user_type_filters.append(user_es.mobile_users()) return q.OR(*user_type_filters) else: # return matching user types and exact matches id_filter = filters.OR( filters.term("_id", user_ids), filters.term("__group_ids", group_ids), ) if user_type_filters: return q.OR( id_filter, filters.OR(*user_type_filters), ) else: return q.filter(id_filter)
def test_user_query(self): json_output = { "query": { "filtered": { "filter": { "and": [ { "term": { "is_active": True } }, { "term": { "base_doc": "couchuser" } }, ] }, "query": { "match_all": {} } } }, "size": SIZE_LIMIT } query = users.UserES() raw_query = query.raw_query self.assertItemsEqual( raw_query['query']['filtered']['filter'].pop('and'), json_output['query']['filtered']['filter'].pop('and')) self.checkQuery(raw_query, json_output, is_raw_query=True)
def test_users_at_accessible_locations(self, mocked_locations): location_ids = [ '09d1a58cb849e53bb3a456a5957d998a', '09d1a58cb849e53bb3a456a5957d99ba' ] mocked_locations.return_value = location_ids query = (users.UserES().users_at_accessible_locations( 'testapp', 'user')) self._check_user_location_query(query, location_ids)
def case_owners(self): # Get user ids for each user that match the demo_user, admin, Unknown Users, or All Mobile Workers filters user_types = EMWF.selected_user_types(self.request) user_type_filters = [] if HQUserType.ADMIN in user_types: user_type_filters.append(user_es.admin_users()) if HQUserType.UNKNOWN in user_types: user_type_filters.append(user_es.unknown_users()) user_type_filters.append(user_es.web_users()) if HQUserType.DEMO_USER in user_types: user_type_filters.append(user_es.demo_users()) if HQUserType.REGISTERED in user_types: user_type_filters.append(user_es.mobile_users()) if len(user_type_filters) > 0: special_q = user_es.UserES().domain( self.domain).OR(*user_type_filters) special_user_ids = special_q.run().doc_ids else: special_user_ids = [] # Get user ids for each user that was specifically selected selected_user_ids = EMWF.selected_user_ids(self.request) # Get group ids for each group that was specified selected_reporting_group_ids = EMWF.selected_reporting_group_ids( self.request) selected_sharing_group_ids = EMWF.selected_sharing_group_ids( self.request) # Get user ids for each user in specified reporting groups report_group_q = HQESQuery(index="groups").domain(self.domain)\ .doc_type("Group")\ .filter(filters.term("_id", selected_reporting_group_ids))\ .fields(["users"]) user_lists = [group["users"] for group in report_group_q.run().hits] selected_reporting_group_users = list(set().union(*user_lists)) # Get ids for each sharing group that contains a user from selected_reporting_group_users OR a user that was specifically selected share_group_q = HQESQuery(index="groups").domain(self.domain)\ .doc_type("Group")\ .filter(filters.term("case_sharing", True))\ .filter(filters.term("users", selected_reporting_group_users+selected_user_ids+special_user_ids))\ .fields([]) sharing_group_ids = share_group_q.run().doc_ids owner_ids = list(set().union(special_user_ids, selected_user_ids, selected_sharing_group_ids, selected_reporting_group_users, sharing_group_ids)) if HQUserType.COMMTRACK in EMWF.selected_user_types(self.request): owner_ids.append("commtrack-system") return owner_ids
def _users_query(self): query = (user_es.UserES().remove_default_filters().OR( user_es.web_users(), user_es.mobile_users())) if 'search_string' in self.request.GET: search_string = self.request.GET['search_string'] fields = [ 'username', 'first_name', 'last_name', 'phone_numbers', 'domain_membership.domain', 'domain_memberships.domain' ] query = query.search_string_query(search_string, fields) return query
def user_es_query(cls, domain, mobile_user_and_group_slugs, request_user): # The queryset returned by this method is location-safe user_ids = cls.selected_user_ids(mobile_user_and_group_slugs) user_types = cls.selected_user_types(mobile_user_and_group_slugs) group_ids = cls.selected_group_ids(mobile_user_and_group_slugs) location_ids = cls.selected_location_ids(mobile_user_and_group_slugs) user_type_filters = [] if HQUserType.ADMIN in user_types: user_type_filters.append(user_es.admin_users()) if HQUserType.UNKNOWN in user_types: user_type_filters.append(user_es.unknown_users()) user_type_filters.append(user_es.web_users()) if HQUserType.DEMO_USER in user_types: user_type_filters.append(user_es.demo_users()) q = user_es.UserES().domain(domain) if HQUserType.ACTIVE in user_types and HQUserType.DEACTIVATED in user_types: q = q.show_inactive() elif HQUserType.DEACTIVATED in user_types: q = q.show_only_inactive() if not request_user.has_permission(domain, 'access_all_locations'): cls._verify_users_are_accessible(domain, request_user, user_ids) return q.OR( filters.term("_id", user_ids), user_es.location(list(SQLLocation.active_objects .get_locations_and_children(location_ids) .accessible_to_user(domain, request_user) .location_ids())), ) elif HQUserType.ACTIVE in user_types or HQUserType.DEACTIVATED in user_types: # return all users with selected user_types user_type_filters.append(user_es.mobile_users()) return q.OR(*user_type_filters) else: # return matching user types and exact matches location_ids = list(SQLLocation.active_objects .get_locations_and_children(location_ids) .location_ids()) id_filter = filters.OR( filters.term("_id", user_ids), filters.term("__group_ids", group_ids), user_es.location(location_ids), ) if user_type_filters: return q.OR( id_filter, filters.OR(*user_type_filters), ) else: return q.filter(id_filter)
def test_users_at_locations_and_descendants(self, locations_patch): location_ids = [ '09d1a58cb849e53bb3a456a5957d998a', '09d1a58cb849e53bb3a456a5957d99ba' ] children_ids = [ '19d1a58cb849e53bb3a456a5957d998a', '19d1a58cb849e53bb3a456a5957d99ba' ] all_ids = location_ids + children_ids locations_patch.return_value = location_ids + children_ids query = ( users.UserES().users_at_locations_and_descendants(location_ids)) self._check_user_location_query(query, all_ids)
def _build_query(self): query = (self.search_class().domain(self.domain).size( self.pagination.count).start(self.pagination.start)) query.es_query['sort'] = self.get_sorting_block() mobile_user_and_group_slugs = self.request.GET.getlist(EMWF.slug) user_types = EMWF.selected_user_types(mobile_user_and_group_slugs) if self.case_filter: query = query.filter(self.case_filter) query = query.NOT(case_es.case_type("user-owner-mapping-case")) if self.case_type: query = query.case_type(self.case_type) if self.case_status: query = query.is_closed(self.case_status == 'closed') if self.request.can_access_all_locations and ( EMWF.show_all_data(mobile_user_and_group_slugs) or EMWF.no_filters_selected(mobile_user_and_group_slugs)): pass elif self.request.can_access_all_locations and EMWF.show_project_data( mobile_user_and_group_slugs): # Show everything but stuff we know for sure to exclude ids_to_exclude = self.get_special_owner_ids( admin=HQUserType.ADMIN not in user_types, unknown=HQUserType.UNKNOWN not in user_types, web=HQUserType.WEB not in user_types, demo=HQUserType.DEMO_USER not in user_types, commtrack=False, ) query = query.NOT(case_es.owner(ids_to_exclude)) elif self.request.can_access_all_locations and EMWF.show_deactivated_data( mobile_user_and_group_slugs): owner_ids = (user_es.UserES().show_only_inactive().domain( self.domain).get_ids()) query = query.OR(case_es.owner(owner_ids)) else: # Only show explicit matches query = query.owner(self.case_owners) if not self.request.can_access_all_locations: query = query.OR(self.scope_filter()) search_string = CaseSearchFilter.get_value(self.request, self.domain) if search_string: query = query.set_query({"query_string": {"query": search_string}}) return query
def get_user_ids_for_user_types(self, admin, unknown, web, demo, commtrack, active=False, deactivated=False): """ referenced from CaseListMixin to fetch user_ids for selected user type :param admin: if admin users to be included :param unknown: if unknown users to be included :param demo: if demo users to be included :param commtrack: if commtrack users to be included :return: user_ids for selected user types """ from corehq.apps.es import filters, users as user_es if not any([admin, unknown, web, demo, commtrack, active, deactivated ]): return [] user_filters = [ filter_ for include, filter_ in [ (admin, user_es.admin_users()), (unknown, filters.OR(user_es.unknown_users())), (web, user_es.web_users()), (demo, user_es.demo_users()), # Sets the is_active filter status correctly for if either active or deactivated users are selected (active ^ deactivated, user_es.is_active(active)), ] if include ] if not user_filters: return [] query = (user_es.UserES().domain( self.domain_object.name).OR(*user_filters).remove_default_filter( 'not_deleted').remove_default_filter('active').fields([])) user_ids = query.run().doc_ids if commtrack: user_ids.append("commtrack-system") if demo: user_ids.append("demo_user_group_id") user_ids.append("demo_user") return user_ids
def _get_special_owner_ids(domain, admin, unknown, web, demo, commtrack): if not any([admin, unknown, web, demo, commtrack]): return [] user_filters = [ filter_ for include, filter_ in [ (admin, user_es.admin_users()), (unknown, filters.OR(user_es.unknown_users())), (web, user_es.web_users()), (demo, user_es.demo_users()), ] if include ] owner_ids = (user_es.UserES().domain(domain).OR(*user_filters).get_ids()) if commtrack: owner_ids.append("commtrack-system") if demo: owner_ids.append("demo_user_group_id") owner_ids.append("demo_user") return owner_ids
def test_user_query(self): json_output = { "query": { "bool": { "filter": [{ "term": { "base_doc": "couchuser" } }, { "term": { "is_active": True } }], "must": { "match_all": {} } } }, "size": SIZE_LIMIT } query = users.UserES() raw_query = query.raw_query self.checkQuery(raw_query, json_output, is_raw_query=True)
def get_special_owner_ids(self, admin, unknown, demo, commtrack): if not any([admin, unknown, demo]): return [] user_filters = [ filter_ for include, filter_ in [ (admin, user_es.admin_users()), (unknown, filters.OR(user_es.unknown_users(), user_es.web_users())), (demo, user_es.demo_users()), ] if include ] query = (user_es.UserES().domain( self.domain).OR(*user_filters).show_inactive().fields([])) owner_ids = query.run().doc_ids if commtrack: owner_ids.append("commtrack-system") if demo: owner_ids.append("demo_user_group_id") owner_ids.append("demo_user") return owner_ids
def user_es_query(cls, domain, mobile_user_and_group_slugs): user_ids = cls.selected_user_ids(mobile_user_and_group_slugs) user_types = cls.selected_user_types(mobile_user_and_group_slugs) group_ids = cls.selected_group_ids(mobile_user_and_group_slugs) location_ids = cls.selected_location_ids(mobile_user_and_group_slugs) user_type_filters = [] if HQUserType.ADMIN in user_types: user_type_filters.append(user_es.admin_users()) if HQUserType.UNKNOWN in user_types: user_type_filters.append(user_es.unknown_users()) user_type_filters.append(user_es.web_users()) if HQUserType.DEMO_USER in user_types: user_type_filters.append(user_es.demo_users()) q = user_es.UserES().domain(domain) if HQUserType.REGISTERED in user_types: # return all users with selected user_types user_type_filters.append(user_es.mobile_users()) return q.OR(*user_type_filters) else: # return matching user types and exact matches location_ids = list(SQLLocation.active_objects .get_locations_and_children(location_ids) .location_ids()) id_filter = filters.OR( filters.term("_id", user_ids), filters.term("__group_ids", group_ids), user_es.location(location_ids), ) if user_type_filters: return q.OR( id_filter, filters.OR(*user_type_filters), ) else: return q.filter(id_filter)
def deactivated_case_owners(domain): owner_ids = ( user_es.UserES().show_only_inactive().domain(domain).get_ids()) return case_es.owner(owner_ids)
def user_es_query(cls, domain, mobile_user_and_group_slugs, request_user): # The queryset returned by this method is location-safe q = user_es.UserES().domain(domain, allow_mirroring=True) if ExpandedMobileWorkerFilter.no_filters_selected( mobile_user_and_group_slugs): return q.show_inactive() user_ids = cls.selected_user_ids(mobile_user_and_group_slugs) user_types = cls.selected_user_types(mobile_user_and_group_slugs) group_ids = cls.selected_group_ids(mobile_user_and_group_slugs) location_ids = cls.selected_location_ids(mobile_user_and_group_slugs) user_type_filters = [] if HQUserType.ADMIN in user_types: user_type_filters.append(user_es.admin_users()) if HQUserType.UNKNOWN in user_types: user_type_filters.append(user_es.unknown_users()) if HQUserType.WEB in user_types: user_type_filters.append(user_es.web_users()) if HQUserType.DEMO_USER in user_types: user_type_filters.append(user_es.demo_users()) if HQUserType.ACTIVE in user_types and HQUserType.DEACTIVATED in user_types: q = q.show_inactive() elif HQUserType.DEACTIVATED in user_types: q = q.show_only_inactive() if not request_user.has_permission(domain, 'access_all_locations'): cls._verify_users_are_accessible(domain, request_user, user_ids) return q.OR( filters.term("_id", user_ids), user_es.location( list( SQLLocation.active_objects.get_locations_and_children( location_ids).accessible_to_user( domain, request_user).location_ids())), ) if HQUserType.ACTIVE in user_types or HQUserType.DEACTIVATED in user_types: # return all users with selected user_types user_type_filters.append(user_es.mobile_users()) return q.OR(*user_type_filters) # return matching user types and exact matches location_ids = list( SQLLocation.active_objects.get_locations_and_children( location_ids).location_ids()) group_id_filter = filters.term("__group_ids", group_ids) if FILTER_ON_GROUPS_AND_LOCATIONS.enabled( domain) and group_ids and location_ids: group_and_location_filter = filters.AND( group_id_filter, user_es.location(location_ids), ) else: group_and_location_filter = filters.OR( group_id_filter, user_es.location(location_ids), ) id_filter = filters.OR( filters.term("_id", user_ids), group_and_location_filter, ) if user_type_filters: return q.OR( id_filter, group_and_location_filter, filters.OR(*user_type_filters), ) return q.filter(id_filter)
def _base_user_es_query(cls, domain, request_user): if not request_user.has_permission(domain, 'access_all_locations'): return super()._base_user_es_query(domain, request_user) domains = list(set(EnterprisePermissions.get_domains(domain)) | {domain}) return user_es.UserES().domains(domains)
def query_deactivated_data(query, domain): owner_ids = ( user_es.UserES().show_only_inactive().domain(domain).get_ids()) return query.OR(case_es.owner(owner_ids))
def _base_user_es_query(cls, domain, request_user): return user_es.UserES().domain(domain, allow_enterprise=True)