def dump_users_and_groups(response, domain):
def _load_memoizer(domain):
group_memoizer = GroupMemoizer(domain=domain)
# load groups manually instead of calling group_memoizer.load_all()
# so that we can detect blank groups
blank_groups = set()
for group in Group.by_domain(domain):
if group.name:
group_memoizer.add_group(group)
else:
blank_groups.add(group)
if blank_groups:
raise GroupNameError(blank_groups=blank_groups)
return group_memoizer
export_file = StringIO()
writer = Excel2007ExportWriter()
group_memoizer = _load_memoizer(domain)
location_cache = LocationIdToSiteCodeCache(domain)
user_data_model = CustomDataFieldsDefinition.get_or_create(
domain,
UserFieldsView.field_type
)
user_headers, user_rows = parse_users(
group_memoizer,
get_all_commcare_users_by_domain(domain),
user_data_model,
location_cache
)
group_headers, group_rows = parse_groups(group_memoizer.groups)
headers = [
('users', [user_headers]),
('groups', [group_headers]),
]
rows = [
('users', user_rows),
('groups', group_rows),
]
domain_obj = Domain.get_by_name(domain)
if domain_obj.commtrack_enabled and domain_obj.supports_multiple_locations_per_user:
headers.append(
('locations', [['username', 'location-sms-code', 'location name (optional)']])
)
rows.append(
('locations', get_location_rows(domain))
)
writer.open(
header_table=headers,
file=export_file,
)
writer.write(rows)
writer.close()
response.write(export_file.getvalue())
def test_get_commcare_users_by_filters(self):
expected_users = [self.ccuser_2, self.ccuser_1]
expected_usernames = [user.username for user in expected_users]
actual_usernames = [
user.username
for user in get_all_commcare_users_by_domain(self.ccdomain.name)
]
self.assertItemsEqual(actual_usernames, expected_usernames)
def parse_users(group_memoizer, domain, user_data_model, location_cache):
def _get_group_names(user):
return sorted(map(
lambda id: group_memoizer.get(id).name,
Group.by_user(user, wrap=False)
), key=alphanumeric_sort_key)
def _make_user_dict(user, group_names, location_cache):
model_data, uncategorized_data = (
user_data_model.get_model_and_uncategorized(user.user_data)
)
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),
'location_code': location_cache.get(user.location_id),
}
unrecognized_user_data_keys = set()
user_groups_length = 0
user_dicts = []
for user in get_all_commcare_users_by_domain(domain):
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'].keys())
user_groups_length = max(user_groups_length, len(group_names))
user_headers = [
'username', 'password', 'name', 'phone-number', 'email',
'language', 'user_id', 'is_active',
]
if domain_has_privilege(domain, privileges.LOCATIONS):
user_headers.append('location_code')
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': range(1, user_groups_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_data_model, location_cache):
def _get_group_names(user):
return sorted(map(
lambda id: group_memoizer.get(id).name,
Group.by_user(user, wrap=False)
), key=alphanumeric_sort_key)
def _make_user_dict(user, group_names, location_cache):
model_data, uncategorized_data = (
user_data_model.get_model_and_uncategorized(user.user_data)
)
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),
'location-sms-code': location_cache.get(user.location_id),
}
user_data_keys = set()
user_groups_length = 0
user_dicts = []
for user in get_all_commcare_users_by_domain(domain):
group_names = _get_group_names(user)
user_dicts.append(_make_user_dict(user, group_names, location_cache))
user_data_keys.update(user.user_data.keys() if user.user_data else [])
user_groups_length = max(user_groups_length, len(group_names))
user_headers = [
'username', 'password', 'name', 'phone-number', 'email',
'language', 'user_id', 'is_active',
]
if domain_has_privilege(domain, privileges.LOCATIONS):
user_headers.append('location-sms-code')
user_data_fields = [f.slug for f in user_data_model.fields]
user_headers.extend(build_data_headers(user_data_fields))
user_headers.extend(build_data_headers(
user_data_keys.difference(set(user_data_fields)),
header_prefix='uncategorized_data'
))
user_headers.extend(json_to_headers(
{'group': range(1, user_groups_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 test_exclude_retired_users(self):
deleted_user = CommCareUser.create(
domain=self.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
deleted_user.retire()
self.assertNotIn(deleted_user.username, [
user.username
for user in get_all_commcare_users_by_domain(self.ccdomain.name)
])
deleted_user.delete()
def test_exclude_retired_users(self):
deleted_user = CommCareUser.create(
domain=self.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
deleted_user.retire()
self.assertNotIn(
deleted_user.username,
[user.username for user in
get_all_commcare_users_by_domain(self.ccdomain.name)]
)
deleted_user.delete()
def test_get_all_commcare_users_by_domain(self):
expected_users = [self.ccuser_2, self.ccuser_1]
expected_usernames = [user.username for user in expected_users]
actual_usernames = [user.username for user in get_all_commcare_users_by_domain(self.ccdomain.name)]
self.assertItemsEqual(actual_usernames, expected_usernames)
def parse_users(group_memoizer, domain, user_data_model, location_cache):
def _get_group_names(user):
return sorted(map(lambda id: group_memoizer.get(id).name,
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 '',
}
unrecognized_user_data_keys = set()
user_groups_length = 0
max_location_length = 0
user_dicts = []
for user in get_all_commcare_users_by_domain(domain):
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'].keys())
user_groups_length = max(user_groups_length, len(group_names))
max_location_length = max(max_location_length,
len(user_dict["location_code"]))
user_headers = [
'username',
'password',
'name',
'phone-number',
'email',
'language',
'role',
'user_id',
'is_active',
'User IMEIs (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': range(1, user_groups_length + 1)}))
if domain_has_privilege(domain, privileges.LOCATIONS):
user_headers.extend(
json_to_headers(
{'location_code': 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_data_model, location_cache):
def _get_group_names(user):
return sorted(map(
lambda id: group_memoizer.get(id).name,
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 '',
}
unrecognized_user_data_keys = set()
user_groups_length = 0
max_location_length = 0
user_dicts = []
for user in get_all_commcare_users_by_domain(domain):
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'].keys())
user_groups_length = max(user_groups_length, len(group_names))
max_location_length = max(max_location_length, len(user_dict["location_code"]))
user_headers = [
'username', 'password', 'name', 'phone-number', 'email',
'language', 'role', 'user_id', 'is_active', 'User IMEIs (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': range(1, user_groups_length + 1)}
))
if domain_has_privilege(domain, privileges.LOCATIONS):
user_headers.extend(json_to_headers(
{'location_code': 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()
