def count_users(request, domain):
from corehq.apps.users.dbaccessors.all_commcare_users import get_commcare_users_by_filters
form = CommCareUserFilterForm(request.GET, domain=domain)
user_filters = {}
if form.is_valid():
user_filters = form.cleaned_data
else:
return HttpResponseBadRequest("Invalid Request")
return json_response({
'count': get_commcare_users_by_filters(domain, user_filters, count_only=True)
})
def dump_usernames(domain, download_id, user_filters, task):
users_count = get_commcare_users_by_filters(domain, user_filters, count_only=True)
DownloadBase.set_progress(task, 0, users_count)
usernames = get_mobile_usernames_by_filters(domain, user_filters)
headers = [('users', [['username']])]
rows = [('users', [[username] for username in usernames])]
location_id = user_filters.get('location_id')
location_name = ""
if location_id:
location = SQLLocation.active_objects.get_or_None(location_id=location_id)
location_name = location.name if location else ""
filename_prefix = "_".join([a for a in [domain, location_name] if bool(a)])
filename = "{}_users.xlsx".format(filename_prefix)
_dump_xlsx_and_expose_download(filename, headers, rows, download_id, task, users_count)
def parse_mobile_users(group_memoizer, domain, user_filters, task=None, total_count=None):
from corehq.apps.users.views.mobile.custom_data_fields import UserFieldsView
fields_definition = CustomDataFieldsDefinition.get_or_create(
domain,
UserFieldsView.field_type
)
location_cache = LocationIdToSiteCodeCache(domain)
unrecognized_user_data_keys = set()
user_groups_length = 0
max_location_length = 0
user_dicts = []
for n, user in enumerate(get_commcare_users_by_filters(domain, user_filters)):
group_names = sorted([
group_memoizer.get(id).name for id in Group.by_user_id(user.user_id, wrap=False)
], key=alphanumeric_sort_key)
user_dict = make_mobile_user_dict(user, group_names, location_cache, domain, fields_definition)
user_dicts.append(user_dict)
unrecognized_user_data_keys.update(user_dict['uncategorized_data'])
user_groups_length = max(user_groups_length, len(group_names))
max_location_length = max(max_location_length, len(user_dict["location_code"]))
if task:
DownloadBase.set_progress(task, n, total_count)
user_headers = [
'username', 'password', 'name', 'phone-number', 'email',
'language', 'role', 'user_id', 'is_active', 'User IMEIs (read only)',
'registered_on (read only)', 'last_submission (read only)', 'last_sync (read only)'
]
if domain_has_privilege(domain, privileges.APP_USER_PROFILES):
user_headers += ['user_profile']
user_data_fields = [f.slug for f in fields_definition.get_fields(include_system=False)]
user_headers.extend(build_data_headers(user_data_fields))
user_headers.extend(build_data_headers(
unrecognized_user_data_keys,
header_prefix='uncategorized_data'
))
user_headers.extend(json_to_headers(
{'group': list(range(1, user_groups_length + 1))}
))
if domain_has_privilege(domain, privileges.LOCATIONS):
user_headers.extend(json_to_headers(
{'location_code': list(range(1, max_location_length + 1))}
))
return user_headers, get_user_rows(user_dicts, user_headers)
def test_get_all_commcare_users_by_domain(self):
from corehq.util.elastic import ensure_index_deleted
from corehq.elastic import get_es_new, send_to_elasticsearch
from corehq.pillows.mappings.user_mapping import USER_INDEX_INFO, USER_INDEX
from pillowtop.es_utils import initialize_index_and_mapping
es = get_es_new()
ensure_index_deleted(USER_INDEX)
initialize_index_and_mapping(es, USER_INDEX_INFO)
send_to_elasticsearch('users', self.ccuser_1.to_json())
send_to_elasticsearch('users', self.ccuser_2.to_json())
es.indices.refresh(USER_INDEX)
usernames = lambda users: [u.username for u in users]
# if no filters are passed, should return all cc-users in the domain
self.assertItemsEqual(
usernames(get_commcare_users_by_filters(self.ccdomain.name, {})),
usernames([self.ccuser_2, self.ccuser_1]))
self.assertEqual(
get_commcare_users_by_filters(self.ccdomain.name, {},
count_only=True), 2)
# can search by username
self.assertItemsEqual(
usernames(
get_commcare_users_by_filters(self.ccdomain.name,
{'search_string': 'user_1'})),
[self.ccuser_1.username])
self.assertEqual(
get_commcare_users_by_filters(self.ccdomain.name,
{'search_string': 'user_1'},
count_only=True), 1)
# can search by role_id
self.assertItemsEqual(
usernames(
get_commcare_users_by_filters(
self.ccdomain.name, {'role_id': self.custom_role._id})),
[self.ccuser_2.username])
self.assertEqual(
get_commcare_users_by_filters(self.ccdomain.name,
{'role_id': self.custom_role._id},
count_only=True), 1)
ensure_index_deleted(USER_INDEX)
def test_get_all_commcare_users_by_domain(self):
from corehq.util.elastic import ensure_index_deleted
from corehq.elastic import get_es_new, send_to_elasticsearch
from corehq.pillows.mappings.user_mapping import USER_INDEX_INFO, USER_INDEX
from pillowtop.es_utils import initialize_index_and_mapping
es = get_es_new()
ensure_index_deleted(USER_INDEX)
initialize_index_and_mapping(es, USER_INDEX_INFO)
send_to_elasticsearch('users', self.ccuser_1.to_json())
send_to_elasticsearch('users', self.ccuser_2.to_json())
es.indices.refresh(USER_INDEX)
usernames = lambda users: [u.username for u in users]
# if no filters are passed, should return all cc-users in the domain
self.assertItemsEqual(
usernames(get_commcare_users_by_filters(self.ccdomain.name, {})),
usernames([self.ccuser_2, self.ccuser_1])
)
self.assertEqual(
get_commcare_users_by_filters(self.ccdomain.name, {}, count_only=True),
2
)
# can search by username
self.assertItemsEqual(
usernames(get_commcare_users_by_filters(self.ccdomain.name, {'search_string': 'user_1'})),
[self.ccuser_1.username]
)
self.assertEqual(
get_commcare_users_by_filters(self.ccdomain.name, {'search_string': 'user_1'}, count_only=True),
1
)
# can search by role_id
self.assertItemsEqual(
usernames(get_commcare_users_by_filters(self.ccdomain.name, {'role_id': self.custom_role._id})),
[self.ccuser_2.username]
)
self.assertEqual(
get_commcare_users_by_filters(self.ccdomain.name, {'role_id': self.custom_role._id}, count_only=True),
1
)
ensure_index_deleted(USER_INDEX)
def count_users_and_groups(domain, user_filters, group_memoizer):
users_count = get_commcare_users_by_filters(domain, user_filters, count_only=True)
groups_count = len(group_memoizer.groups)
return users_count + groups_count
def parse_users(group_memoizer, domain, user_data_model, location_cache,
user_filters, task, total_count):
def _get_group_names(user):
return sorted([
group_memoizer.get(id).name
for id in Group.by_user_id(user.user_id, wrap=False)
],
key=alphanumeric_sort_key)
def _get_devices(user):
"""
Returns a comma-separated list of IMEI numbers of the user's devices, sorted with most-recently-used first
"""
return ', '.join([
device.device_id for device in sorted(
user.devices, key=lambda d: d.last_used, reverse=True)
])
def _make_user_dict(user, group_names, location_cache):
model_data, uncategorized_data = (
user_data_model.get_model_and_uncategorized(user.user_data))
role = user.get_role(domain)
location_codes = []
try:
location_codes.append(location_cache.get(user.location_id))
except SQLLocation.DoesNotExist:
pass
for location_id in user.assigned_location_ids:
# skip if primary location_id, as it is already added to the start of list above
if location_id != user.location_id:
try:
location_codes.append(location_cache.get(location_id))
except SQLLocation.DoesNotExist:
pass
return {
'data':
model_data,
'uncategorized_data':
uncategorized_data,
'group':
group_names,
'name':
user.full_name,
'password':
"******", # dummy display string for passwords
'phone-number':
user.phone_number,
'email':
user.email,
'username':
user.raw_username,
'language':
user.language,
'user_id':
user._id,
'is_active':
str(user.is_active),
'User IMEIs (read only)':
_get_devices(user),
'location_code':
location_codes,
'role':
role.name if role else '',
'registered_on (read only)':
user.created_on.strftime('%Y-%m-%d %H:%M:%S')
if user.created_on else ''
}
unrecognized_user_data_keys = set()
user_groups_length = 0
max_location_length = 0
user_dicts = []
for n, user in enumerate(
get_commcare_users_by_filters(domain, user_filters)):
group_names = _get_group_names(user)
user_dict = _make_user_dict(user, group_names, location_cache)
user_dicts.append(user_dict)
unrecognized_user_data_keys.update(user_dict['uncategorized_data'])
user_groups_length = max(user_groups_length, len(group_names))
max_location_length = max(max_location_length,
len(user_dict["location_code"]))
DownloadBase.set_progress(task, n, total_count)
user_headers = [
'username', 'password', 'name', 'phone-number', 'email', 'language',
'role', 'user_id', 'is_active', 'User IMEIs (read only)',
'registered_on (read only)'
]
user_data_fields = [
f.slug for f in user_data_model.get_fields(include_system=False)
]
user_headers.extend(build_data_headers(user_data_fields))
user_headers.extend(
build_data_headers(unrecognized_user_data_keys,
header_prefix='uncategorized_data'))
user_headers.extend(
json_to_headers({'group': list(range(1, user_groups_length + 1))}))
if domain_has_privilege(domain, privileges.LOCATIONS):
user_headers.extend(
json_to_headers(
{'location_code': list(range(1, max_location_length + 1))}))
def _user_rows():
for user_dict in user_dicts:
row = dict(flatten_json(user_dict))
yield [row.get(header) or '' for header in user_headers]
return user_headers, _user_rows()
def parse_users(group_memoizer, domain, user_filters, task=None, total_count=None):
from corehq.apps.users.views.mobile.custom_data_fields import UserFieldsView
fields_definition = CustomDataFieldsDefinition.get_or_create(
domain,
UserFieldsView.field_type
)
location_cache = LocationIdToSiteCodeCache(domain)
def _get_group_names(user):
return sorted([
group_memoizer.get(id).name for id in Group.by_user_id(user.user_id, wrap=False)
], key=alphanumeric_sort_key)
def _get_devices(user):
"""
Returns a comma-separated list of IMEI numbers of the user's devices, sorted with most-recently-used first
"""
return ', '.join([device.device_id for device in sorted(
user.devices, key=lambda d: d.last_used, reverse=True
)])
def _make_user_dict(user, group_names, location_cache):
model_data, uncategorized_data = (
fields_definition.get_model_and_uncategorized(user.metadata)
)
role = user.get_role(domain)
profile = None
if PROFILE_SLUG in user.metadata and domain_has_privilege(domain, privileges.APP_USER_PROFILES):
try:
profile = CustomDataFieldsProfile.objects.get(id=user.metadata[PROFILE_SLUG])
except CustomDataFieldsProfile.DoesNotExist:
profile = None
activity = user.reporting_metadata
location_codes = []
try:
location_codes.append(location_cache.get(user.location_id))
except SQLLocation.DoesNotExist:
pass
for location_id in user.assigned_location_ids:
# skip if primary location_id, as it is already added to the start of list above
if location_id != user.location_id:
try:
location_codes.append(location_cache.get(location_id))
except SQLLocation.DoesNotExist:
pass
def _format_date(date):
return date.strftime('%Y-%m-%d %H:%M:%S') if date else ''
return {
'data': model_data,
'uncategorized_data': uncategorized_data,
'group': group_names,
'name': user.full_name,
'password': "******", # dummy display string for passwords
'phone-number': user.phone_number,
'email': user.email,
'username': user.raw_username,
'language': user.language,
'user_id': user._id,
'is_active': str(user.is_active),
'User IMEIs (read only)': _get_devices(user),
'location_code': location_codes,
'role': role.name if role else '',
'user_profile': profile.name if profile else '',
'registered_on (read only)': _format_date(user.created_on),
'last_submission (read only)': _format_date(activity.last_submission_for_user.submission_date),
'last_sync (read only)': activity.last_sync_for_user.sync_date,
}
unrecognized_user_data_keys = set()
user_groups_length = 0
max_location_length = 0
user_dicts = []
for n, user in enumerate(get_commcare_users_by_filters(domain, user_filters)):
group_names = _get_group_names(user)
user_dict = _make_user_dict(user, group_names, location_cache)
user_dicts.append(user_dict)
unrecognized_user_data_keys.update(user_dict['uncategorized_data'])
user_groups_length = max(user_groups_length, len(group_names))
max_location_length = max(max_location_length, len(user_dict["location_code"]))
if task:
DownloadBase.set_progress(task, n, total_count)
user_headers = [
'username', 'password', 'name', 'phone-number', 'email',
'language', 'role', 'user_id', 'is_active', 'User IMEIs (read only)',
'registered_on (read only)', 'last_submission (read only)', 'last_sync (read only)'
]
if domain_has_privilege(domain, privileges.APP_USER_PROFILES):
user_headers += ['user_profile']
user_data_fields = [f.slug for f in fields_definition.get_fields(include_system=False)]
user_headers.extend(build_data_headers(user_data_fields))
user_headers.extend(build_data_headers(
unrecognized_user_data_keys,
header_prefix='uncategorized_data'
))
user_headers.extend(json_to_headers(
{'group': list(range(1, user_groups_length + 1))}
))
if domain_has_privilege(domain, privileges.LOCATIONS):
user_headers.extend(json_to_headers(
{'location_code': list(range(1, max_location_length + 1))}
))
def _user_rows():
for user_dict in user_dicts:
row = dict(flatten_json(user_dict))
yield [row.get(header) or '' for header in user_headers]
return user_headers, _user_rows()
def count_users_and_groups(domain, user_filters, group_memoizer):
users_count = get_commcare_users_by_filters(domain, user_filters, count_only=True)
groups_count = len(group_memoizer.groups)
return users_count + groups_count
def parse_users(group_memoizer, domain, user_data_model, location_cache, user_filters, task, total_count):
def _get_group_names(user):
return sorted([group_memoizer.get(id).name for id in Group.by_user(user, wrap=False)], key=alphanumeric_sort_key)
def _get_devices(user):
"""
Returns a comma-separated list of IMEI numbers of the user's devices, sorted with most-recently-used first
"""
return ', '.join([device.device_id for device in sorted(
user.devices, key=lambda d: d.last_used, reverse=True
)])
def _make_user_dict(user, group_names, location_cache):
model_data, uncategorized_data = (
user_data_model.get_model_and_uncategorized(user.user_data)
)
role = user.get_role(domain)
location_codes = []
try:
location_codes.append(location_cache.get(user.location_id))
except SQLLocation.DoesNotExist:
pass
for location_id in user.assigned_location_ids:
# skip if primary location_id, as it is already added to the start of list above
if location_id != user.location_id:
try:
location_codes.append(location_cache.get(location_id))
except SQLLocation.DoesNotExist:
pass
return {
'data': model_data,
'uncategorized_data': uncategorized_data,
'group': group_names,
'name': user.full_name,
'password': "******", # dummy display string for passwords
'phone-number': user.phone_number,
'email': user.email,
'username': user.raw_username,
'language': user.language,
'user_id': user._id,
'is_active': str(user.is_active),
'User IMEIs (read only)': _get_devices(user),
'location_code': location_codes,
'role': role.name if role else '',
'registered_on (read only)': user.created_on.strftime('%Y-%m-%d %H:%M:%S') if user.created_on else ''
}
unrecognized_user_data_keys = set()
user_groups_length = 0
max_location_length = 0
user_dicts = []
for n, user in enumerate(get_commcare_users_by_filters(domain, user_filters)):
group_names = _get_group_names(user)
user_dict = _make_user_dict(user, group_names, location_cache)
user_dicts.append(user_dict)
unrecognized_user_data_keys.update(user_dict['uncategorized_data'])
user_groups_length = max(user_groups_length, len(group_names))
max_location_length = max(max_location_length, len(user_dict["location_code"]))
DownloadBase.set_progress(task, n, total_count)
user_headers = [
'username', 'password', 'name', 'phone-number', 'email',
'language', 'role', 'user_id', 'is_active', 'User IMEIs (read only)',
'registered_on (read only)']
user_data_fields = [f.slug for f in user_data_model.get_fields(include_system=False)]
user_headers.extend(build_data_headers(user_data_fields))
user_headers.extend(build_data_headers(
unrecognized_user_data_keys,
header_prefix='uncategorized_data'
))
user_headers.extend(json_to_headers(
{'group': list(range(1, user_groups_length + 1))}
))
if domain_has_privilege(domain, privileges.LOCATIONS):
user_headers.extend(json_to_headers(
{'location_code': list(range(1, max_location_length + 1))}
))
def _user_rows():
for user_dict in user_dicts:
row = dict(flatten_json(user_dict))
yield [row.get(header) or '' for header in user_headers]
return user_headers, _user_rows()
