def setUpClass(cls):
super(TestUserSetupUtils, cls).setUpClass()
cls.domain_obj = Domain(name=cls.domain)
cls.domain_obj.save()
cls.location_types, cls.locations = setup_enikshay_locations(
cls.domain)
# set up data fields
user_fields = CustomDataFieldsDefinition.get_or_create(
cls.domain, CUSTOM_USER_DATA_FIELD_TYPE)
usertypes = [
t for types in LOC_TYPES_TO_USER_TYPES.values() for t in types
]
user_fields.fields = [
CustomDataField(slug='usertype',
is_multiple_choice=True,
choices=usertypes),
CustomDataField(slug='is_test'),
CustomDataField(slug='nikshay_id'),
]
user_fields.save()
location_fields = CustomDataFieldsDefinition.get_or_create(
cls.domain, LocationFieldsView.field_type)
location_fields.fields = [
CustomDataField(slug='nikshay_code', is_required=True)
]
location_fields.save()
cls.web_user = WebUser.create(cls.domain, 'blah', 'password')
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,
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)
# This is only for domains using the multiple locations feature flag
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 save_custom_fields(domain, definition_name, custom_fields):
if custom_fields:
fields_definitions = CustomDataFieldsDefinition.get_or_create(domain, definition_name)
need_save = False
for custom_field in custom_fields:
name = custom_field.get('name')
label = custom_field.get('label')
choices = custom_field.get('choices') or []
existing_fields = filter(lambda field: field.slug == name, fields_definitions.fields)
if not existing_fields:
need_save = True
fields_definitions.fields.append(
CustomDataField(
slug=name,
label=label or name,
is_required=False,
choices=choices,
is_multiple_choice=custom_field.get('is_multiple_choice', False)
)
)
else:
existing_field = existing_fields[0]
if set(existing_field.choices) != set(choices):
existing_field.choices = choices
need_save = True
if need_save:
fields_definitions.save()
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,
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)
# This is only for domains using the multiple locations feature flag
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 get_location_data_model(domain):
from .views import LocationFieldsView
from corehq.apps.custom_data_fields import CustomDataFieldsDefinition
return CustomDataFieldsDefinition.get_or_create(
domain,
LocationFieldsView.field_type,
)
def get_location_data_model(domain):
from .views import LocationFieldsView
from corehq.apps.custom_data_fields import CustomDataFieldsDefinition
return CustomDataFieldsDefinition.get_or_create(
domain,
LocationFieldsView.field_type,
)
def setUpClass(cls):
super(TestUserSetupUtils, cls).setUpClass()
cls.domain_obj = Domain(name=cls.domain)
cls.domain_obj.save()
cls.location_types, cls.locations = setup_enikshay_locations(
cls.domain)
with mock.patch(
'corehq.apps.locations.tasks._create_or_unarchive_users',
mock.MagicMock()):
for location_type in cls.location_types.values():
if location_type.code in AGENCY_LOCATION_TYPES:
location_type.has_user = True
location_type.save()
# set up data fields
user_fields = CustomDataFieldsDefinition.get_or_create(
cls.domain, CUSTOM_USER_DATA_FIELD_TYPE)
usertypes = [
'to', 'tbhv', 'mo-phi', 'sts', 'stls', 'lt-dmc', 'lt-cdst', 'dto',
'deo', 'cto', 'sto', 'drtb-hiv'
]
user_fields.fields = [
CustomDataField(
slug='usertype', is_multiple_choice=True, choices=usertypes),
CustomDataField(slug='is_test'),
CustomDataField(slug='nikshay_id'),
] + [
CustomDataField(slug=slug, is_required=False)
for slug, _, __ in AGENCY_USER_FIELDS
]
user_fields.save()
location_fields = CustomDataFieldsDefinition.get_or_create(
cls.domain, LocationFieldsView.field_type)
location_fields.fields = [
CustomDataField(slug='nikshay_code', is_required=True)
] + [
CustomDataField(slug=slug)
for slug, _, __ in AGENCY_LOCATION_FIELDS
]
location_fields.save()
cls.web_user = WebUser.create(cls.domain, 'blah', 'password')
def dump_users_and_groups(domain, download_id, user_filters):
from corehq.apps.users.views.mobile.custom_data_fields import UserFieldsView
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
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,
domain,
user_data_model,
location_cache,
user_filters
)
group_headers, group_rows = parse_groups(group_memoizer.groups)
headers = [
('users', [user_headers]),
('groups', [group_headers]),
]
rows = [
('users', user_rows),
('groups', group_rows),
]
use_transfer = settings.SHARED_DRIVE_CONF.transfer_enabled
filename = "user_export_{}_{}.xlsx".format(domain, uuid.uuid4().hex)
file_path = get_download_file_path(use_transfer, filename)
writer.open(
header_table=headers,
file=file_path,
)
writer.write(rows)
writer.close()
expose_download(use_transfer, file_path, filename, download_id, 'xlsx')
def setUpClass(cls):
super(LocationFixturesDataTest, cls).setUpClass()
cls.user = create_restore_user(cls.domain, 'user', '123')
cls.loc_fields = CustomDataFieldsDefinition.get_or_create(cls.domain, LocationFieldsView.field_type)
cls.loc_fields.fields = [
CustomDataField(slug='baseball_team'),
CustomDataField(slug='favorite_passtime'),
]
cls.loc_fields.save()
cls.field_slugs = [f.slug for f in cls.loc_fields.fields]
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)
user_data_model = CustomDataFieldsDefinition.get_or_create(
domain,
UserFieldsView.field_type
)
user_data_fields = [f.slug for f in user_data_model.fields]
user_headers, user_rows = parse_users(group_memoizer,
CommCareUser.by_domain(domain),
user_data_fields)
group_headers, group_rows = parse_groups(group_memoizer.groups)
headers = [
('users', [user_headers]),
('groups', [group_headers]),
]
rows = [
('users', user_rows),
('groups', group_rows),
]
commtrack_enabled = Domain.get_by_name(domain).commtrack_enabled
if commtrack_enabled:
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 save_custom_fields(self, definition_name, custom_fields):
fields_definitions = CustomDataFieldsDefinition.get_or_create(self.domain, definition_name)
for custom_field in custom_fields:
if not filter(lambda field: field.slug == custom_field, fields_definitions.fields):
fields_definitions.fields.append(
CustomDataField(
slug=custom_field,
label=custom_field,
is_required=False,
)
)
fields_definitions.save()
def prepare_domain(domain_name):
from corehq.apps.commtrack.tests.util import bootstrap_domain
domain = bootstrap_domain(domain_name)
previous = None
for name, administrative in [
("MOHSW", True),
("MSDZONE", True),
("REGION", True),
("DISTRICT", True),
("FACILITY", False)
]:
previous, _ = LocationType.objects.get_or_create(
domain=domain_name,
name=name,
parent_type=previous,
administrative=administrative,
)
generator.instantiate_accounting_for_tests()
account = BillingAccount.get_or_create_account_by_domain(
domain.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan_by_domain(
domain, edition=SoftwarePlanEdition.ADVANCED
)
commtrack = domain.commtrack_settings
commtrack.actions.append(
CommtrackActionConfig(action='receipts',
keyword='delivered',
caption='Delivered')
)
commtrack.save()
subscription = Subscription.new_domain_subscription(
account,
domain.name,
plan
)
subscription.is_active = True
subscription.save()
ils_config = ILSGatewayConfig(enabled=True, domain=domain.name, all_stock_data=True)
ils_config.save()
fields_definition = CustomDataFieldsDefinition.get_or_create(domain.name, 'LocationFields')
fields_definition.fields.append(CustomDataField(
slug='group',
label='Group',
is_required=False,
choices=['A', 'B', 'C'],
is_multiple_choice=False
))
fields_definition.save()
return domain
def prepare_domain(domain_name):
from corehq.apps.commtrack.tests.util import bootstrap_domain
domain = bootstrap_domain(domain_name)
previous = None
for name, administrative in [
("MOHSW", True),
("MSDZONE", True),
("REGION", True),
("DISTRICT", True),
("FACILITY", False)
]:
previous, _ = LocationType.objects.get_or_create(
domain=domain_name,
name=name,
parent_type=previous,
administrative=administrative,
)
generator.instantiate_accounting()
account = BillingAccount.get_or_create_account_by_domain(
domain.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.ADVANCED
)
commtrack = domain.commtrack_settings
commtrack.actions.append(
CommtrackActionConfig(action='receipts',
keyword='delivered',
caption='Delivered')
)
commtrack.save()
subscription = Subscription.new_domain_subscription(
account,
domain.name,
plan
)
subscription.is_active = True
subscription.save()
ils_config = ILSGatewayConfig(enabled=True, domain=domain.name, all_stock_data=True)
ils_config.save()
fields_definition = CustomDataFieldsDefinition.get_or_create(domain.name, 'LocationFields')
fields_definition.fields.append(CustomDataField(
slug='group',
label='Group',
is_required=False,
choices=['A', 'B', 'C'],
is_multiple_choice=False
))
fields_definition.save()
return domain
def dump_users_and_groups(response, domain):
from corehq.apps.users.views.mobile.custom_data_fields import UserFieldsView
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,
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),
]
writer.open(
header_table=headers,
file=export_file,
)
writer.write(rows)
writer.close()
response.write(export_file.getvalue())
def update_custom_data_models(domain_link, limit_types=None):
if domain_link.is_remote:
master_results = remote_custom_data_models(domain_link, limit_types)
else:
master_results = local_custom_data_models(domain_link.master_domain,
limit_types)
for field_type, field_definitions in master_results.items():
model = CustomDataFieldsDefinition.get_or_create(
domain_link.linked_domain, field_type)
model.fields = [
CustomDataField.wrap(field_def) for field_def in field_definitions
]
model.save()
def _parse_custom_properties(product):
product_data_model = CustomDataFieldsDefinition.get_or_create(domain, ProductFieldsView.field_type)
product_data_fields = [f.slug for f in product_data_model.fields]
model_data = {}
uncategorized_data = {}
for prop, val in product.product_data.iteritems():
if prop in product_data_fields:
model_data["data: " + prop] = encode_if_needed(val)
else:
uncategorized_data["uncategorized_data: " + prop] = encode_if_needed(val)
return model_data, uncategorized_data
def _parse_custom_properties(product):
product_data_model = CustomDataFieldsDefinition.get_or_create(
domain, ProductFieldsView.field_type)
product_data_fields = [f.slug for f in product_data_model.fields]
model_data = {}
uncategorized_data = {}
for prop, val in six.iteritems(product.product_data):
if prop in product_data_fields:
model_data['data: ' + prop] = encode_if_needed(val)
else:
uncategorized_data['uncategorized_data: ' +
prop] = encode_if_needed(val)
return model_data, uncategorized_data
def setUpClass(cls):
super(TestIndexedLocationsFixture, cls).setUpClass()
cls.user = create_restore_user(cls.domain, 'user', '123')
cls.loc_fields = CustomDataFieldsDefinition.get_or_create(cls.domain, LocationFieldsView.field_type)
cls.loc_fields.fields = [
CustomDataField(slug='is_test', index_in_fixture=True),
CustomDataField(slug='favorite_color'),
]
cls.loc_fields.save()
cls.field_slugs = [f.slug for f in cls.loc_fields.fields]
for location in cls.locations.values():
location.metadata = {
'is_test': 'no',
'favorite_color': 'blue',
}
location.save()
def dump_users_and_groups(response, domain):
from corehq.apps.users.views.mobile.custom_data_fields import UserFieldsView
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, 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),
]
writer.open(
header_table=headers,
file=export_file,
)
writer.write(rows)
writer.close()
response.write(export_file.getvalue())
def dump_users_and_groups(domain, download_id):
from corehq.apps.users.views.mobile.custom_data_fields import UserFieldsView
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
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, 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),
]
use_transfer = settings.SHARED_DRIVE_CONF.transfer_enabled
file_path = _get_download_file_path(domain, use_transfer)
writer.open(
header_table=headers,
file=file_path,
)
writer.write(rows)
writer.close()
common_kwargs = dict(
mimetype=Format.from_format('xlsx').mimetype,
content_disposition='attachment; filename="{fname}"'.format(
fname='{}_users.xlsx'.format(domain)),
download_id=download_id,
)
if use_transfer:
expose_file_download(file_path,
use_transfer=use_transfer,
**common_kwargs)
else:
expose_cached_download(FileWrapper(open(file_path, 'r')),
expiry=(1 * 60 * 60),
file_extension='xlsx',
**common_kwargs)
