def test_archive(self):
test_state = make_loc(
'teststate',
type='state',
parent=self.user.location
)
test_state.save()
original_count = len(list(Location.by_domain(self.domain.name)))
loc = self.user.location
loc.archive()
# it should also archive children
self.assertEqual(
len(list(Location.by_domain(self.domain.name))),
original_count - 2
)
self.assertEqual(
len(Location.root_locations(self.domain.name)),
0
)
loc.unarchive()
# and unarchive children
self.assertEqual(
len(list(Location.by_domain(self.domain.name))),
original_count
)
self.assertEqual(
len(Location.root_locations(self.domain.name)),
1
)
def test_full_delete(self):
test_loc = make_loc(
'test_loc',
type='state',
parent=self.user.location
)
test_loc.save()
original_count = len(list(Location.by_domain(self.domain.name)))
loc = self.user.location
loc.full_delete()
# it should also delete children
self.assertEqual(
len(list(Location.by_domain(self.domain.name))),
original_count - 2
)
self.assertEqual(
len(Location.root_locations(self.domain.name)),
0
)
# permanently gone from sql db
self.assertEqual(
len(SQLLocation.objects.all()),
0
)
def location_fixture_generator(user, version, last_sync=None):
"""
By default this will generate a fixture for the users
location and it's "footprint", meaning the path
to a root location through parent hierarchies.
There is an admin feature flag that will make this generate
a fixture with ALL locations for the domain.
"""
project = user.project
if (not project or not project.commtrack_enabled
or not project.commtrack_settings
or not project.commtrack_settings.sync_location_fixtures):
return []
if toggles.SYNC_ALL_LOCATIONS.enabled(user.domain):
location_db = _location_footprint(Location.by_domain(user.domain))
else:
locations = []
if user.location:
# add users location (and ancestors) to fixture
locations.append(user.location)
# optionally add all descendants as well
if user.location.location_type_object.view_descendants:
locations += user.location.descendants
if user.project.supports_multiple_locations_per_user:
# this might add duplicate locations but we filter that out later
locations += user.locations
location_db = _location_footprint(locations)
if not should_sync_locations(last_sync, location_db):
return []
root = ElementTree.Element('fixture',
{'id': 'commtrack:locations',
'user_id': user.user_id})
loc_types = project.location_types
type_to_slug_mapping = dict((ltype.name, ltype.code) for ltype in loc_types)
def location_type_lookup(location_type):
return type_to_slug_mapping.get(location_type, unicode_slug(location_type))
if toggles.SYNC_ALL_LOCATIONS.enabled(user.domain):
root_locations = Location.root_locations(user.domain)
else:
root_locations = filter(lambda loc: loc.parent_id is None, location_db.by_id.values())
if not root_locations:
return []
else:
_append_children(root, location_db, root_locations, location_type_lookup)
return [root]
def test_location_queries(self):
test_state1 = make_loc("teststate1", type="state", parent=self.user.location, domain=self.domain.name)
test_state2 = make_loc("teststate2", type="state", parent=self.user.location, domain=self.domain.name)
test_village1 = make_loc("testvillage1", type="village", parent=test_state1, domain=self.domain.name)
test_village1.site_code = "tv1"
test_village1.save()
test_village2 = make_loc("testvillage2", type="village", parent=test_state2, domain=self.domain.name)
def compare(list1, list2):
self.assertEqual(set([l._id for l in list1]), set([l._id for l in list2]))
# descendants
compare([test_state1, test_state2, test_village1, test_village2], self.user.location.descendants)
# children
compare([test_state1, test_state2], self.user.location.children)
# siblings
compare([test_state2], test_state1.siblings())
# parent and parent_id
self.assertEqual(self.user.location._id, test_state1.parent_id)
self.assertEqual(self.user.location._id, test_state1.parent._id)
# is_root
self.assertTrue(self.user.location.is_root)
self.assertFalse(test_state1.is_root)
# Location.root_locations
compare([self.user.location], Location.root_locations(self.domain.name))
# Location.filter_by_type
compare([test_village1, test_village2], Location.filter_by_type(self.domain.name, "village"))
compare([test_village1], Location.filter_by_type(self.domain.name, "village", test_state1))
# Location.get_in_domain
test_village2.domain = "rejected"
bootstrap_location_types("rejected")
test_village2.save()
self.assertEqual(Location.get_in_domain(self.domain.name, test_village1._id)._id, test_village1._id)
self.assertIsNone(Location.get_in_domain(self.domain.name, test_village2._id))
self.assertIsNone(Location.get_in_domain(self.domain.name, "not-a-real-id"))
self.assertEqual(
{loc._id for loc in [self.user.location, test_state1, test_state2, test_village1]},
set(SQLLocation.objects.filter(domain=self.domain.name).location_ids()),
)
# Location.by_site_code
self.assertEqual(test_village1._id, Location.by_site_code(self.domain.name, "tv1")._id)
self.assertIsNone(None, Location.by_site_code(self.domain.name, "notreal"))
# Location.by_domain
compare([self.user.location, test_state1, test_state2, test_village1], Location.by_domain(self.domain.name))
def test_archive(self):
test_state = make_loc('teststate',
type='state',
parent=self.user.location)
test_state.save()
original_count = len(list(Location.by_domain(self.domain.name)))
loc = self.user.sql_location
loc.archive()
# it should also archive children
self.assertEqual(len(list(Location.by_domain(self.domain.name))),
original_count - 2)
self.assertEqual(len(Location.root_locations(self.domain.name)), 0)
loc.unarchive()
# and unarchive children
self.assertEqual(len(list(Location.by_domain(self.domain.name))),
original_count)
self.assertEqual(len(Location.root_locations(self.domain.name)), 1)
def test_full_delete(self):
test_loc = make_loc('test_loc',
type='state',
parent=self.user.location)
test_loc.save()
original_count = len(list(Location.by_domain(self.domain.name)))
loc = self.user.sql_location
loc.full_delete()
# it should also delete children
self.assertEqual(len(list(Location.by_domain(self.domain.name))),
original_count - 2)
self.assertEqual(len(Location.root_locations(self.domain.name)), 0)
# permanently gone from sql db
self.assertEqual(len(SQLLocation.objects.all()), 0)
def copy_locations(self):
from corehq.apps.locations.models import LocationType
from corehq.apps.locations.models import Location
from corehq.apps.locations.views import LocationFieldsView
self._copy_custom_data(LocationFieldsView.field_type)
location_types = LocationType.objects.by_domain(self.existing_domain)
location_types_map = {}
for location_type in location_types:
if location_type.parent_type_id:
location_type.parent_type_id = location_types_map[
location_type.parent_type_id]
old_id, new_id = self.save_sql_copy(location_type, self.new_domain)
location_types_map[old_id] = new_id
def copy_location_hierarchy(location, id_map):
new_lineage = []
for ancestor in location.sql_location.lineage:
try:
new_lineage.append(id_map[ancestor])
except KeyError:
self.stderr.write(
"Ancestor {} for location {} missing".format(
location._id, ancestor))
location.lineage = new_lineage
old_type_name = location.location_type_name
if not self.no_commmit:
location._sql_location_type = LocationType.objects.get(
domain=self.new_domain,
name=old_type_name,
)
children = location.get_children()
old_id, new_id = self.save_couch_copy(location, self.new_domain)
id_map[old_id] = new_id
for child in children:
copy_location_hierarchy(child, id_map)
locations = Location.root_locations(self.existing_domain)
for location in locations:
copy_location_hierarchy(location, {})
def location_fixture_generator(user, version, case_sync_op=None, last_sync=None):
"""
By default this will generate a fixture for the users
location and it's "footprint", meaning the path
to a root location through parent hierarchies.
There is an admin feature flag that will make this generate
a fixture with ALL locations for the domain.
"""
project = user.project
if (not project or not project.commtrack_enabled
or not project.commtrack_settings
or not project.commtrack_settings.sync_location_fixtures):
return []
rewrapped_user = CommTrackUser.wrap(user.to_json())
if toggles.SYNC_ALL_LOCATIONS.enabled(user.domain):
location_db = _location_footprint(Location.by_domain(user.domain))
else:
location_db = _location_footprint(rewrapped_user.locations)
if not should_sync_locations(last_sync, location_db):
return []
root = ElementTree.Element('fixture',
{'id': 'commtrack:locations',
'user_id': user.user_id})
loc_types = project.commtrack_settings.location_types
type_to_slug_mapping = dict((ltype.name, ltype.code) for ltype in loc_types)
def location_type_lookup(location_type):
return type_to_slug_mapping.get(location_type, unicode_slug(location_type))
if toggles.SYNC_ALL_LOCATIONS.enabled(user.domain):
root_locations = Location.root_locations(user.domain)
else:
root_locations = filter(lambda loc: loc.parent_id is None, location_db.by_id.values())
_append_children(root, location_db, root_locations, location_type_lookup)
return [root]
def copy_locations(self):
from corehq.apps.locations.models import LocationType
from corehq.apps.locations.models import Location
from corehq.apps.locations.views import LocationFieldsView
self._copy_custom_data(LocationFieldsView.field_type)
location_types = LocationType.objects.by_domain(self.existing_domain)
previous_location_type = None
for location_type in location_types:
if previous_location_type:
location_type.parent_type = previous_location_type
self.save_sql_copy(location_type, self.new_domain)
previous_location_type = location_type
def copy_location_hierarchy(location, id_map):
new_lineage = []
for ancestor in location.lineage:
try:
new_lineage.append(id_map[ancestor])
except KeyError:
self.stderr.write("Ancestor {} for location {} missing".format(location._id, ancestor))
location.lineage = new_lineage
old_type_name = location.location_type_name
if not self.no_commmit:
location._sql_location_type = LocationType.objects.get(
domain=self.new_domain,
name=old_type_name,
)
children = location.children
old_id, new_id = self.save_couch_copy(location, self.new_domain)
id_map[old_id] = new_id
for child in children:
copy_location_hierarchy(child, id_map)
locations = Location.root_locations(self.existing_domain)
for location in locations:
copy_location_hierarchy(location, {})
def test_location_queries(self):
test_state1 = make_loc(
'teststate1',
type='state',
parent=self.user.location,
domain=self.domain.name
)
test_state2 = make_loc(
'teststate2',
type='state',
parent=self.user.location,
domain=self.domain.name
)
test_village1 = make_loc(
'testvillage1',
type='village',
parent=test_state1,
domain=self.domain.name
)
test_village1.site_code = 'tv1'
test_village1.save()
test_village2 = make_loc(
'testvillage2',
type='village',
parent=test_state2,
domain=self.domain.name
)
def compare(list1, list2):
self.assertEqual(
set([l._id for l in list1]),
set([l._id for l in list2])
)
# descendants
compare(
[test_state1, test_state2, test_village1, test_village2],
self.user.location.descendants
)
# children
compare(
[test_state1, test_state2],
self.user.location.children
)
# siblings
compare(
[test_state2],
test_state1.siblings()
)
# parent and parent_id
self.assertEqual(
self.user.location._id,
test_state1.parent_id
)
self.assertEqual(
self.user.location._id,
test_state1.parent._id
)
# is_root
self.assertTrue(self.user.location.is_root)
self.assertFalse(test_state1.is_root)
# Location.root_locations
compare(
[self.user.location],
Location.root_locations(self.domain.name)
)
# Location.filter_by_type
compare(
[test_village1, test_village2],
Location.filter_by_type(self.domain.name, 'village')
)
compare(
[test_village1],
Location.filter_by_type(self.domain.name, 'village', test_state1)
)
# Location.get_in_domain
test_village2.domain = 'rejected'
bootstrap_location_types('rejected')
test_village2.save()
self.assertEqual(
Location.get_in_domain(self.domain.name, test_village1._id)._id,
test_village1._id
)
self.assertIsNone(
Location.get_in_domain(self.domain.name, test_village2._id),
)
self.assertIsNone(
Location.get_in_domain(self.domain.name, 'not-a-real-id'),
)
self.assertEqual(
{loc._id for loc in [self.user.location, test_state1, test_state2,
test_village1]},
set(SQLLocation.objects.filter(domain=self.domain.name).location_ids()),
)
# Location.by_site_code
self.assertEqual(
test_village1._id,
Location.by_site_code(self.domain.name, 'tv1')._id
)
self.assertIsNone(
None,
Location.by_site_code(self.domain.name, 'notreal')
)
# Location.by_domain
compare(
[self.user.location, test_state1, test_state2, test_village1],
Location.by_domain(self.domain.name)
)
def test_location_queries(self):
test_state1 = make_loc(
'teststate1',
type='state',
parent=self.user.locations[0]
)
test_state2 = make_loc(
'teststate2',
type='state',
parent=self.user.locations[0]
)
test_village1 = make_loc(
'testvillage1',
type='village',
parent=test_state1
)
test_village1.site_code = 'tv1'
test_village1.save()
test_village2 = make_loc(
'testvillage2',
type='village',
parent=test_state2
)
def compare(list1, list2):
self.assertEqual(
set([l._id for l in list1]),
set([l._id for l in list2])
)
# descendants
compare(
[test_state1, test_state2, test_village1, test_village2],
self.user.locations[0].descendants
)
# children
compare(
[test_state1, test_state2],
self.user.locations[0].children
)
# siblings
compare(
[test_state2],
test_state1.siblings()
)
# parent and parent_id
self.assertEqual(
self.user.locations[0]._id,
test_state1.parent_id
)
self.assertEqual(
self.user.locations[0]._id,
test_state1.parent._id
)
# is_root
self.assertTrue(self.user.locations[0].is_root)
self.assertFalse(test_state1.is_root)
# Location.root_locations
compare(
[self.user.locations[0]],
Location.root_locations(self.domain.name)
)
# Location.filter_by_type
compare(
[test_village1, test_village2],
Location.filter_by_type(self.domain.name, 'village')
)
compare(
[test_village1],
Location.filter_by_type(self.domain.name, 'village', test_state1)
)
# Location.filter_by_type_count
self.assertEqual(
2,
Location.filter_by_type_count(self.domain.name, 'village')
)
self.assertEqual(
1,
Location.filter_by_type_count(self.domain.name, 'village', test_state1)
)
# Location.get_in_domain
test_village2.domain = 'rejected'
test_village2.save()
self.assertEqual(
Location.get_in_domain(self.domain.name, test_village1._id)._id,
test_village1._id
)
self.assertIsNone(
Location.get_in_domain(self.domain.name, test_village2._id),
)
self.assertIsNone(
Location.get_in_domain(self.domain.name, 'not-a-real-id'),
)
# Location.all_locations
compare(
[self.user.locations[0], test_state1, test_state2, test_village1],
Location.all_locations(self.domain.name)
)
# Location.by_site_code
self.assertEqual(
test_village1._id,
Location.by_site_code(self.domain.name, 'tv1')._id
)
self.assertIsNone(
None,
Location.by_site_code(self.domain.name, 'notreal')
)
# Location.by_domain
compare(
[self.user.locations[0], test_state1, test_state2, test_village1],
Location.by_domain(self.domain.name)
)
def test_location_queries(self):
test_state1 = make_loc(
'teststate1',
type='state',
parent=self.user.location,
domain=self.domain.name
)
test_state2 = make_loc(
'teststate2',
type='state',
parent=self.user.location,
domain=self.domain.name
)
test_village1 = make_loc(
'testvillage1',
type='village',
parent=test_state1,
domain=self.domain.name
)
test_village1.site_code = 'tv1'
test_village1.save()
test_village2 = make_loc(
'testvillage2',
type='village',
parent=test_state2,
domain=self.domain.name
)
def compare(list1, list2):
self.assertEqual(
set([l._id for l in list1]),
set([l._id for l in list2])
)
# descendants
compare(
[test_state1, test_state2, test_village1, test_village2],
self.user.location.descendants
)
# children
compare(
[test_state1, test_state2],
self.user.location.get_children()
)
# parent and parent_location_id
self.assertEqual(
self.user.location.location_id,
test_state1.parent_location_id
)
self.assertEqual(
self.user.location.location_id,
test_state1.parent._id
)
# Location.root_locations
compare(
[self.user.location],
Location.root_locations(self.domain.name)
)
# Location.filter_by_type
compare(
[test_village1, test_village2],
Location.filter_by_type(self.domain.name, 'village')
)
compare(
[test_village1],
Location.filter_by_type(self.domain.name, 'village', test_state1)
)
create_domain('rejected')
bootstrap_location_types('rejected')
test_village2.domain = 'rejected'
test_village2.save()
self.assertEqual(
{loc.location_id for loc in [self.user.location, test_state1, test_state2,
test_village1]},
set(SQLLocation.objects.filter(domain=self.domain.name).location_ids()),
)
# Location.by_site_code
self.assertEqual(
test_village1._id,
Location.by_site_code(self.domain.name, 'tv1')._id
)
self.assertIsNone(
None,
Location.by_site_code(self.domain.name, 'notreal')
)
# Location.by_domain
compare(
[self.user.location, test_state1, test_state2, test_village1],
Location.by_domain(self.domain.name)
)
def test_location_queries(self):
test_state1 = make_loc(
'teststate1',
type='state',
parent=self.user.location,
domain=self.domain.name
)
test_state2 = make_loc(
'teststate2',
type='state',
parent=self.user.location,
domain=self.domain.name
)
test_village1 = make_loc(
'testvillage1',
type='village',
parent=test_state1,
domain=self.domain.name
)
test_village1.site_code = 'tv1'
test_village1.save()
test_village2 = make_loc(
'testvillage2',
type='village',
parent=test_state2,
domain=self.domain.name
)
def compare(list1, list2):
self.assertEqual(
set([l._id for l in list1]),
set([l._id for l in list2])
)
# descendants
compare(
[test_state1, test_state2, test_village1, test_village2],
self.user.location.descendants
)
# children
compare(
[test_state1, test_state2],
self.user.location.children
)
# siblings
compare(
[test_state2],
test_state1.siblings()
)
# parent and parent_id
self.assertEqual(
self.user.location._id,
test_state1.parent_id
)
self.assertEqual(
self.user.location._id,
test_state1.parent._id
)
# is_root
self.assertTrue(self.user.location.is_root)
self.assertFalse(test_state1.is_root)
# Location.root_locations
compare(
[self.user.location],
Location.root_locations(self.domain.name)
)
# Location.filter_by_type
compare(
[test_village1, test_village2],
Location.filter_by_type(self.domain.name, 'village')
)
compare(
[test_village1],
Location.filter_by_type(self.domain.name, 'village', test_state1)
)
# Location.get_in_domain
test_village2.domain = 'rejected'
bootstrap_location_types('rejected')
test_village2.save()
self.assertEqual(
Location.get_in_domain(self.domain.name, test_village1._id)._id,
test_village1._id
)
self.assertIsNone(
Location.get_in_domain(self.domain.name, test_village2._id),
)
self.assertIsNone(
Location.get_in_domain(self.domain.name, 'not-a-real-id'),
)
def _all_locations(domain):
return Location.view(
'locations/hierarchy',
startkey=[domain],
endkey=[domain, {}],
reduce=False,
include_docs=True
).all()
compare(
[self.user.location, test_state1, test_state2, test_village1],
_all_locations(self.domain.name)
)
# Location.by_site_code
self.assertEqual(
test_village1._id,
Location.by_site_code(self.domain.name, 'tv1')._id
)
self.assertIsNone(
None,
Location.by_site_code(self.domain.name, 'notreal')
)
# Location.by_domain
compare(
[self.user.location, test_state1, test_state2, test_village1],
Location.by_domain(self.domain.name)
)
