def test_get_assigned_locations_default(self, assigned_locations_patch):
assigned_locations_patch.return_value = self.user_assigned_locations
emwf = ExpandedMobileWorkerFilter(self.request)
loc_defaults = emwf._get_assigned_locations_default()
self.assertEqual(
loc_defaults,
list(map(emwf.utils.location_tuple, self.user_assigned_locations)))
def test_default_selections_for_restricted_access(
self, assigned_locations_patch):
self.request.can_access_all_locations = False
self.request.project = self.domain
emwf = ExpandedMobileWorkerFilter(self.request)
emwf.get_default_selections()
assert assigned_locations_patch.called
def _get_users_filter(self, mobile_user_and_group_slugs):
user_ids = (EMWF.user_es_query(
self.domain, mobile_user_and_group_slugs,
self.request.couch_user).values_list('_id', flat=True))
if HQUserType.UNKNOWN in EMWF.selected_user_types(
mobile_user_and_group_slugs):
user_ids.append(SYSTEM_USER_ID)
return form_es.user_id(user_ids)
def _get_users_filter(self, mobile_user_and_group_slugs):
user_ids = (EMWF.user_es_query(self.domain,
mobile_user_and_group_slugs,
self.request.couch_user)
.values_list('_id', flat=True))
if HQUserType.UNKNOWN in EMWF.selected_user_types(mobile_user_and_group_slugs):
user_ids.append(SYSTEM_USER_ID)
return form_es.user_id(user_ids)
def _es_extra_filters(self):
if FormsByApplicationFilter.has_selections(self.request):
def form_filter(form):
app_id = form.get('app_id', None)
if app_id and app_id != MISSING_APP_ID:
return {
'and': [{
'term': {
'xmlns.exact': form['xmlns']
}
}, {
'term': {
'app_id': app_id
}
}]
}
return {'term': {'xmlns.exact': form['xmlns']}}
form_values = self.all_relevant_forms.values()
if form_values:
yield {'or': [form_filter(f) for f in form_values]}
truthy_only = functools.partial(filter, None)
mobile_user_and_group_slugs = self.request.GET.getlist(
ExpandedMobileWorkerFilter.slug)
users_data = ExpandedMobileWorkerFilter.pull_users_and_groups(
self.domain, mobile_user_and_group_slugs, include_inactive=True)
all_mobile_workers_selected = 't__0' in self.request.GET.getlist('emw')
if not all_mobile_workers_selected or users_data.admin_and_demo_users:
yield {
'terms': {
'form.meta.userID':
truthy_only(u.user_id for u in users_data.combined_users)
}
}
else:
negated_ids = util.get_all_users_by_domain(
self.domain,
user_filter=HQUserType.all_but_users(),
simplified=True,
)
yield {
'not': {
'terms': {
'form.meta.userID':
truthy_only(user.user_id for user in negated_ids)
}
}
}
if HQUserType.UNKNOWN not in ExpandedMobileWorkerFilter.selected_user_types(
mobile_user_and_group_slugs):
yield {'not': {'term': {'xmlns.exact': SYSTEM_FORM_XMLNS}}}
def _es_extra_filters(self):
if FormsByApplicationFilter.has_selections(self.request):
def form_filter(form):
app_id = form.get('app_id', None)
if app_id and app_id != MISSING_APP_ID:
return {'and': [{'term': {'xmlns.exact': form['xmlns']}},
{'term': {'app_id': app_id}}]}
return {'term': {'xmlns.exact': form['xmlns']}}
form_values = self.all_relevant_forms.values()
if form_values:
yield {'or': [form_filter(f) for f in form_values]}
truthy_only = functools.partial(filter, None)
mobile_user_and_group_slugs = self.request.GET.getlist(ExpandedMobileWorkerFilter.slug)
users_data = ExpandedMobileWorkerFilter.pull_users_and_groups(
self.domain,
mobile_user_and_group_slugs,
include_inactive=True
)
all_mobile_workers_selected = 't__0' in self.request.GET.getlist('emw')
if not all_mobile_workers_selected or users_data.admin_and_demo_users:
yield {
'terms': {
'form.meta.userID': truthy_only(
u.user_id for u in users_data.combined_users
)
}
}
else:
negated_ids = util.get_all_users_by_domain(
self.domain,
user_filter=HQUserType.all_but_users(),
simplified=True,
)
yield {
'not': {
'terms': {
'form.meta.userID': truthy_only(
user.user_id for user in negated_ids
)
}
}
}
props = truthy_only(self.request.GET.get('form_data', '').split(','))
for prop in props:
yield {
'term': {'__props_for_querying': prop}
}
if HQUserType.UNKNOWN not in ExpandedMobileWorkerFilter.selected_user_types(mobile_user_and_group_slugs):
yield {
'not': {'term': {'xmlns.exact': SYSTEM_FORM_XMLNS}}
}
def case_users_and_owners(self):
users_data = ExpandedMobileWorkerFilter.pull_users_from_es(
self.domain, self.request, fields=[])
user_ids = filter(None, [u["_id"] for u in users_data["hits"]["hits"]])
group_owner_ids = []
for user_id in user_ids:
group_owner_ids.extend([
group._id
for group in Group.by_user(user_id)
if group.case_sharing
])
if HQUserType.COMMTRACK in ExpandedMobileWorkerFilter.user_types(self.request):
user_ids.append("commtrack-system")
return user_ids, filter(None, group_owner_ids)
def case_users_and_owners(self):
users_data = ExpandedMobileWorkerFilter.pull_users_from_es(
self.domain, self.request, fields=[])
user_ids = filter(None, [u["_id"] for u in users_data["hits"]["hits"]])
group_owner_ids = []
for user_id in user_ids:
group_owner_ids.extend([
group._id for group in Group.by_user(user_id)
if group.case_sharing
])
if HQUserType.COMMTRACK in ExpandedMobileWorkerFilter.user_types(
self.request):
user_ids.append("commtrack-system")
return user_ids, filter(None, group_owner_ids)
def _form_rows(self, domain):
time_filter = form_es.submitted
datespan = DateSpan(datetime.now() - timedelta(days=self.window),
datetime.utcnow())
apps = get_brief_apps_in_domain(domain.name)
apps = {a.id: a.name for a in apps}
users_filter = form_es.user_id(
EMWF.user_es_query(
domain.name,
['t__0'], # All mobile workers
self.couch_user).values_list('_id', flat=True))
query = (form_es.FormES().domain(domain.name).filter(
time_filter(gte=datespan.startdate,
lt=datespan.enddate_adjusted)).filter(users_filter))
rows = []
for hit in query.run().hits:
username = hit['form']['meta']['username']
submitted = self._format_date(
datetime.strptime(hit['received_on'][:19],
'%Y-%m-%dT%H:%M:%S'))
rows.append([
hit['form']['@name'],
submitted,
apps[hit['app_id']] if hit['app_id'] in
apps else 'App not found',
username,
] + self._domain_properties(domain))
return rows
def case_users_and_owners(self):
users_data = ExpandedMobileWorkerFilter.pull_users_and_groups(self.domain, self.request, True, True)
user_ids = filter(None, [u.get("user_id") for u in users_data["combined_users"]])
group_owner_ids = []
for user_id in user_ids:
group_owner_ids.extend([group._id for group in Group.by_user(user_id) if group.case_sharing])
return user_ids, filter(None, group_owner_ids)
def es_query(self):
if not getattr(self, 'es_response', None):
q = {
"query": {
"range": {
self.time_field: {
"from": self.datespan.startdate_param,
"to": self.datespan.enddate_param,
"include_upper": False}}},
"filter": {"and": ADD_TO_ES_FILTER["forms"][:]}}
xmlnss = filter(None, [f["xmlns"] for f in self.all_relevant_forms.values()])
if xmlnss:
q["filter"]["and"].append({"terms": {"xmlns.exact": xmlnss}})
users_data = ExpandedMobileWorkerFilter.pull_users_and_groups(self.domain, self.request, True, True)
if "t__0" not in self.request.GET.getlist("emw") or users_data["admin_and_demo_users"]:
q["filter"]["and"].append(
{"terms": {"form.meta.userID": filter(None, [u["user_id"] for u in users_data["combined_users"]])}})
else:
negated_ids = util.get_all_users_by_domain(self.domain, user_filter=HQUserType.all_but_users(), simplified=True)
ids = filter(None, [user['user_id'] for user in negated_ids])
q["filter"]["and"].append({"not": {"terms": {"form.meta.userID": ids}}})
for cp in filter(None, self.request.GET.get('form_data', "").split(",")):
q["filter"]["and"].append({"term": {"__props_for_querying": cp.lower()}})
q["sort"] = self.get_sorting_block() if self.get_sorting_block() else [{self.time_field : {"order": "desc"}}]
self.es_response = es_query(params={"domain.exact": self.domain}, q=q, es_url=XFORM_INDEX + '/xform/_search',
start_at=self.pagination.start, size=self.pagination.count)
return self.es_response
def user_query(self, pagination=True):
mobile_user_and_group_slugs = set(
# Cater for old ReportConfigs
self.request.GET.getlist('location_restricted_mobile_worker') +
self.request.GET.getlist(ExpandedMobileWorkerFilter.slug))
user_query = ExpandedMobileWorkerFilter.user_es_query(
self.domain,
mobile_user_and_group_slugs,
self.request.couch_user,
)
user_query = (user_query.set_sorting_block(self.get_sorting_block()))
if pagination:
user_query = (user_query.size(self.pagination.count).start(
self.pagination.start))
if self.selected_app_id:
# adding nested filter for reporting_metadata.last_submissions.app_id
# and reporting_metadata.last_syncs.app_id when app is selected
last_submission_filter = filters.nested(
'reporting_metadata.last_submissions',
filters.term('reporting_metadata.last_submissions.app_id',
self.selected_app_id))
last_sync_filter = filters.nested(
'reporting_metadata.last_syncs',
filters.term("reporting_metadata.last_syncs.app_id",
self.selected_app_id))
user_query = user_query.OR(last_submission_filter,
last_sync_filter)
return user_query
def user_query(self, pagination=True):
mobile_user_and_group_slugs = set(
# Cater for old ReportConfigs
self.request.GET.getlist('location_restricted_mobile_worker') +
self.request.GET.getlist(ExpandedMobileWorkerFilter.slug)
)
user_query = ExpandedMobileWorkerFilter.user_es_query(
self.domain,
mobile_user_and_group_slugs,
self.request.couch_user,
)
user_query = (user_query
.set_sorting_block(self.get_sorting_block()))
if pagination:
user_query = (user_query
.size(self.pagination.count)
.start(self.pagination.start))
if self.selected_app_id:
# adding nested filter for reporting_metadata.last_submissions.app_id
# and reporting_metadata.last_syncs.app_id when app is selected
last_submission_filter = filters.nested('reporting_metadata.last_submissions',
filters.term('reporting_metadata.last_submissions.app_id',
self.selected_app_id)
)
last_sync_filter = filters.nested('reporting_metadata.last_syncs',
filters.term("reporting_metadata.last_syncs.app_id",
self.selected_app_id)
)
user_query = user_query.OR(last_submission_filter,
last_sync_filter
)
return user_query
def _to_form_export_instance_filters(self, can_access_all_locations, accessible_location_ids):
emwf_selections = self.cleaned_data["emwf_form_filter"]
return FormExportInstanceFilters(
date_period=DatePeriod(
period_type=self.cleaned_data['date_range'],
days=self.cleaned_data['days'],
begin=self.cleaned_data['start_date'],
end=self.cleaned_data['end_date'],
),
users=ExpandedMobileWorkerFilter.selected_user_ids(emwf_selections),
reporting_groups=ExpandedMobileWorkerFilter.selected_reporting_group_ids(emwf_selections),
locations=ExpandedMobileWorkerFilter.selected_location_ids(emwf_selections),
user_types=ExpandedMobileWorkerFilter.selected_user_types(emwf_selections),
can_access_all_locations=can_access_all_locations,
accessible_location_ids=accessible_location_ids,
)
def _to_form_export_instance_filters(self, can_access_all_locations, accessible_location_ids):
emwf_selections = [x['id'] for x in self.cleaned_data["emwf_form_filter"]]
return FormExportInstanceFilters(
date_period=DatePeriod(
period_type=self.cleaned_data['date_range'],
days=self.cleaned_data['days'],
begin=self.cleaned_data['start_date'],
end=self.cleaned_data['end_date'],
),
users=ExpandedMobileWorkerFilter.selected_user_ids(emwf_selections),
reporting_groups=ExpandedMobileWorkerFilter.selected_reporting_group_ids(emwf_selections),
locations=ExpandedMobileWorkerFilter.selected_location_ids(emwf_selections),
user_types=ExpandedMobileWorkerFilter.selected_user_types(emwf_selections),
can_access_all_locations=can_access_all_locations,
accessible_location_ids=accessible_location_ids,
)
def is_query_too_big(domain, mobile_user_and_group_slugs):
from corehq.apps.reports.filters.users import ExpandedMobileWorkerFilter
user_es_query = ExpandedMobileWorkerFilter.user_es_query(
domain,
mobile_user_and_group_slugs,
)
return user_es_query.count() > USER_QUERY_LIMIT
def is_query_too_big(domain, mobile_user_and_group_slugs, request_user):
from corehq.apps.reports.filters.users import ExpandedMobileWorkerFilter
user_es_query = ExpandedMobileWorkerFilter.user_es_query(
domain,
mobile_user_and_group_slugs,
request_user,
)
return user_es_query.count() > USER_QUERY_LIMIT
def test_with_web_type_and_active_deactivated_user_slug(self):
mobile_user_and_group_slugs = ['t__6', 'u__active1', 'u__deactive1']
user_query = ExpandedMobileWorkerFilter.user_es_query(
self.domain,
mobile_user_and_group_slugs,
self.user,
)
user_ids = user_query.values_list('_id', flat=True)
expected_ids = ['web1', 'active1', 'deactive1']
self.assertCountEqual(user_ids, expected_ids)
def _get_users_filter(self, mobile_user_and_group_slugs):
truthy_only = functools.partial(filter, None)
users_data = EMWF.pull_users_and_groups(self.domain,
mobile_user_and_group_slugs,
include_inactive=True)
selected_user_types = EMWF.selected_user_types(
mobile_user_and_group_slugs)
all_mobile_workers_selected = HQUserType.REGISTERED in selected_user_types
if not all_mobile_workers_selected or users_data.admin_and_demo_users:
return form_es.user_id(
truthy_only(u.user_id for u in users_data.combined_users))
else:
negated_ids = util.get_all_users_by_domain(
self.domain,
user_filter=HQUserType.all_but_users(),
simplified=True,
)
return es_filters.NOT(
form_es.user_id(
truthy_only(user.user_id for user in negated_ids)))
def get_user_ids(self):
mobile_user_and_group_slugs = set(
# Cater for old ReportConfigs
self.request.GET.getlist('location_restricted_mobile_worker') +
self.request.GET.getlist(ExpandedMobileWorkerFilter.slug))
user_ids = ExpandedMobileWorkerFilter.user_es_query(
self.domain,
mobile_user_and_group_slugs,
self.request.couch_user,
).values_list('_id', flat=True)
return user_ids
def report_config(self):
emw = [u.user_id for u in ExpandedMobileWorkerFilter.pull_users_and_groups(
self.domain, self.request, True, True).combined_users]
if self.datespan.enddate - timedelta(days=30) > self.datespan.startdate:
self.datespan.startdate = self.datespan.enddate - timedelta(days=30)
config = dict(
domain=self.domain,
startdate=self.datespan.startdate,
enddate=self.datespan.enddate,
emw=tuple(emw)
)
return config
def _es_extra_filters(self):
if FormsByApplicationFilter.has_selections(self.request):
def form_filter(form):
app_id = form.get('app_id', None)
if app_id and app_id != MISSING_APP_ID:
return {
'and': [{
'term': {
'xmlns.exact': form['xmlns']
}
}, {
'term': {
'app_id': app_id
}
}]
}
return {'term': {'xmlns.exact': form['xmlns']}}
form_values = self.all_relevant_forms.values()
if form_values:
yield {'or': [form_filter(f) for f in form_values]}
truthy_only = functools.partial(filter, None)
users_data = ExpandedMobileWorkerFilter.pull_users_and_groups(
self.domain, self.request, True, True, include_inactive=True)
all_mobile_workers_selected = 't__0' in self.request.GET.getlist('emw')
if not all_mobile_workers_selected or users_data.admin_and_demo_users:
yield {
'terms': {
'form.meta.userID':
truthy_only(u.user_id for u in users_data.combined_users)
}
}
else:
negated_ids = util.get_all_users_by_domain(
self.domain,
user_filter=HQUserType.all_but_users(),
simplified=True,
)
yield {
'not': {
'terms': {
'form.meta.userID':
truthy_only(user.user_id for user in negated_ids)
}
}
}
props = truthy_only(self.request.GET.get('form_data', '').split(','))
for prop in props:
yield {'term': {'__props_for_querying': prop.lower()}}
def _get_users_filter(self, mobile_user_and_group_slugs):
truthy_only = functools.partial(filter, None)
users_data = EMWF.pull_users_and_groups(
self.domain,
mobile_user_and_group_slugs,
include_inactive=True
)
selected_user_types = EMWF.selected_user_types(mobile_user_and_group_slugs)
all_mobile_workers_selected = HQUserType.REGISTERED in selected_user_types
if not all_mobile_workers_selected or users_data.admin_and_demo_users:
return form_es.user_id(truthy_only(
u.user_id for u in users_data.combined_users
))
else:
negated_ids = util.get_all_users_by_domain(
self.domain,
user_filter=HQUserType.all_but_users(),
simplified=True,
)
return es_filters.NOT(form_es.user_id(truthy_only(
user.user_id for user in negated_ids
)))
def es_query(self):
time_filter = form_es.submitted if self.by_submission_time else form_es.completed
mobile_user_and_group_slugs = self.request.GET.getlist(EMWF.slug)
query = (form_es.FormES()
.domain(self.domain)
.filter(time_filter(gte=self.datespan.startdate,
lt=self.datespan.enddate_adjusted))
.filter(self._get_users_filter(mobile_user_and_group_slugs)
if not EMWF.no_filters_selected(mobile_user_and_group_slugs)
else match_all())) # If no filters are selected, return all results
# filter results by app and xmlns if applicable
if FormsByApplicationFilter.has_selections(self.request):
form_values = list(self.all_relevant_forms.values())
if form_values:
query = query.OR(*[self._form_filter(f) for f in form_values])
# Exclude system forms unless they selected "Unknown User"
if HQUserType.UNKNOWN not in EMWF.selected_user_types(mobile_user_and_group_slugs):
for xmlns in SYSTEM_FORM_XMLNS_MAP.keys():
query = query.NOT(form_es.xmlns(xmlns))
return query
def users(self):
mobile_user_and_group_slugs = self.request.GET.getlist(ExpandedMobileWorkerFilter.slug)
limit_user_ids = []
if self.selected_app_id:
limit_user_ids = get_all_user_ids_submitted(self.domain, self.selected_app_id)
users_data = ExpandedMobileWorkerFilter.pull_users_and_groups(
self.domain,
mobile_user_and_group_slugs,
include_inactive=False,
limit_user_ids=limit_user_ids,
)
return users_data.combined_users
def hits(self, domain_name):
time_filter = form_es.submitted
datespan = DateSpan(datetime.now() - timedelta(days=self.window),
datetime.utcnow())
users_filter = form_es.user_id(
EMWF.user_es_query(
domain_name,
['t__0'], # All mobile workers
self.couch_user).values_list('_id', flat=True))
query = (form_es.FormES().domain(domain_name).filter(
time_filter(gte=datespan.startdate,
lt=datespan.enddate_adjusted)).filter(users_filter))
return query.run().hits
def hits(self, domain_name):
time_filter = form_es.submitted
datespan = DateSpan(datetime.now() - timedelta(days=self.window), datetime.utcnow())
users_filter = form_es.user_id(EMWF.user_es_query(domain_name,
['t__0'], # All mobile workers
self.couch_user)
.values_list('_id', flat=True))
query = (form_es.FormES()
.domain(domain_name)
.filter(time_filter(gte=datespan.startdate,
lt=datespan.enddate_adjusted))
.filter(users_filter))
return query.run().hits
def report_config(self):
emw = [
u.user_id
for u in ExpandedMobileWorkerFilter.pull_users_and_groups(
self.domain, self.request, True, True).combined_users
]
if self.datespan.enddate - timedelta(
days=30) > self.datespan.startdate:
self.datespan.startdate = self.datespan.enddate - timedelta(
days=30)
config = dict(domain=self.domain,
startdate=self.datespan.startdate,
enddate=self.datespan.enddate,
emw=tuple(emw))
return config
def user_query(self):
# partially inspired by ApplicationStatusReport.user_query
mobile_user_and_group_slugs = set(
self.request.GET.getlist(ExpandedMobileWorkerFilter.slug)
) or set(['t__0']) # default to all mobile workers on initial load
user_query = ExpandedMobileWorkerFilter.user_es_query(
self.domain,
mobile_user_and_group_slugs,
self.request.couch_user,
)
user_query = user_query.size(0)
user_query = user_query.aggregations([
DateHistogram('last_submission', 'reporting_metadata.last_submission_for_user.submission_date', '1d'),
DateHistogram('last_sync', 'reporting_metadata.last_sync_for_user.sync_date', '1d')
])
return user_query
def user_query(self):
# partially inspired by ApplicationStatusReport.user_query
mobile_user_and_group_slugs = set(
self.request.GET.getlist(ExpandedMobileWorkerFilter.slug)
) or set(['t__0']) # default to all mobile workers on initial load
user_query = ExpandedMobileWorkerFilter.user_es_query(
self.domain,
mobile_user_and_group_slugs,
self.request.couch_user,
)
user_query = user_query.size(0)
user_query = user_query.aggregations([
DateHistogram('last_submission', 'reporting_metadata.last_submission_for_user.submission_date', '1d'),
DateHistogram('last_sync', 'reporting_metadata.last_sync_for_user.sync_date', '1d')
])
return user_query
def _es_extra_filters(self):
truthy_only = functools.partial(filter, None)
form_values = self.all_relevant_forms.values()
if form_values:
yield {
'or': [
{'and': [{'term': {'xmlns.exact': f['xmlns']}},
{'term': {'app_id': f['app_id']}}]}
for f in form_values
]
}
users_data = ExpandedMobileWorkerFilter.pull_users_and_groups(
self.domain, self.request, True, True)
all_mobile_workers_selected = 't__0' in self.request.GET.getlist('emw')
if not all_mobile_workers_selected or users_data.admin_and_demo_users:
yield {
'terms': {
'form.meta.userID': truthy_only(
u.user_id for u in users_data.combined_users
)
}
}
else:
negated_ids = util.get_all_users_by_domain(
self.domain,
user_filter=HQUserType.all_but_users(),
simplified=True,
)
yield {
'not': {
'terms': {
'form.meta.userID': truthy_only(
user.user_id for user in negated_ids
)
}
}
}
props = truthy_only(self.request.GET.get('form_data', '').split(','))
for prop in props:
yield {
'term': {'__props_for_querying': prop.lower()}
}
def user_query(self, pagination=True):
mobile_user_and_group_slugs = set(
# Cater for old ReportConfigs
self.request.GET.getlist('location_restricted_mobile_worker') +
self.request.GET.getlist(ExpandedMobileWorkerFilter.slug))
user_query = ExpandedMobileWorkerFilter.user_es_query(
self.domain,
mobile_user_and_group_slugs,
self.request.couch_user,
)
user_query = (user_query.set_sorting_block(self.get_sorting_block()))
if pagination:
user_query = (user_query.size(self.pagination.count).start(
self.pagination.start))
if self.selected_app_id:
user_query = user_query.nested(
self.sort_base,
filters.term(self.sort_filter, self.selected_app_id))
return user_query
def es_query(self):
time_filter = form_es.submitted if self.by_submission_time else form_es.completed
mobile_user_and_group_slugs = self.request.GET.getlist(EMWF.slug)
query = (form_es.FormES()
.domain(self.domain)
.filter(time_filter(gte=self.datespan.startdate,
lt=self.datespan.enddate_adjusted))
.filter(self._get_users_filter(mobile_user_and_group_slugs)))
# filter results by app and xmlns if applicable
if FormsByApplicationFilter.has_selections(self.request):
form_values = list(self.all_relevant_forms.values())
if form_values:
query = query.OR(*[self._form_filter(f) for f in form_values])
# Exclude system forms unless they selected "Unknown User"
if HQUserType.UNKNOWN not in EMWF.selected_user_types(mobile_user_and_group_slugs):
query = query.NOT(form_es.xmlns(SYSTEM_FORM_XMLNS))
return query
def rows(self):
if self.warehouse:
mobile_user_and_group_slugs = set(
# Cater for old ReportConfigs
self.request.GET.getlist('location_restricted_mobile_worker') +
self.request.GET.getlist(ExpandedMobileWorkerFilter.slug))
users = ExpandedMobileWorkerFilter.user_es_query(
self.domain,
mobile_user_and_group_slugs,
self.request.couch_user,
).values_list('_id', flat=True)
sort_clause = self.get_sql_sort()
rows = ApplicationStatusFact.objects.filter(
user_dim__user_id__in=users).order_by(
sort_clause).select_related('user_dim', 'app_dim')
if self.selected_app_id:
rows = rows.filter(
app_dim__application_id=self.selected_app_id)
self._total_records = rows.count()
return self.process_users(rows)
else:
users = self.user_query().run()
self._total_records = users.total
return self.process_rows(users.hits)
def rows(self):
if self.warehouse:
mobile_user_and_group_slugs = set(
# Cater for old ReportConfigs
self.request.GET.getlist('location_restricted_mobile_worker') +
self.request.GET.getlist(ExpandedMobileWorkerFilter.slug)
)
users = ExpandedMobileWorkerFilter.user_es_query(
self.domain,
mobile_user_and_group_slugs,
self.request.couch_user,
).values_list('_id', flat=True)
sort_clause = self.get_sql_sort()
rows = ApplicationStatusFact.objects.filter(
user_dim__user_id__in=users
).order_by(sort_clause).select_related('user_dim', 'app_dim')
if self.selected_app_id:
rows = rows.filter(app_dim__application_id=self.selected_app_id)
self._total_records = rows.count()
return self.process_users(rows)
else:
users = self.user_query().run()
self._total_records = users.total
return self.process_rows(users.hits)
def test_get_assigned_locations_default(self, assigned_locations_patch):
assigned_locations_patch.return_value = self.user_assigned_locations
emwf = ExpandedMobileWorkerFilter(self.request)
loc_defaults = emwf._get_assigned_locations_default()
self.assertEqual(loc_defaults, map(emwf.utils.location_tuple, self.user_assigned_locations))
def _extract_location_id(location_id_slug):
from corehq.apps.reports.filters.users import ExpandedMobileWorkerFilter
selected_ids = ExpandedMobileWorkerFilter.selected_location_ids(
[location_id_slug])
return selected_ids[0] if selected_ids else None
def _get_users_filter(self, mobile_user_and_group_slugs):
user_ids = (EMWF.user_es_query(
self.domain, mobile_user_and_group_slugs,
self.request.couch_user).values_list('_id', flat=True))
return form_es.user_id(user_ids)
