def get_location(domain, user, site_code): location = None if user and CommTrackUser.wrap(user.to_json()).location: loc = CommTrackUser.wrap(user.to_json()).location location = get_supply_point(domain, loc=loc) elif site_code: location = get_supply_point(domain, site_code=site_code) return location
def save(self, user): commtrack_user = CommTrackUser.wrap(user.to_json()) location_id = self.cleaned_data['supply_point'] if location_id: loc = Location.get(location_id) commtrack_user.clear_locations() commtrack_user.add_location(loc, create_sp_if_missing=True)
def update_commtrack_form(self): if self.request.method == "POST" and self.request.POST['form_type'] == "commtrack": return CommtrackUserForm(self.request.POST, domain=self.domain) # currently only support one location on the UI linked_loc = CommTrackUser.wrap(self.editable_user.to_json()).location initial_id = linked_loc._id if linked_loc else None return CommtrackUserForm(domain=self.domain, initial={'supply_point': initial_id})
def save(self, user): commtrack_user = CommTrackUser.wrap(user.to_json()) location_id = self.cleaned_data["supply_point"] if location_id: loc = Location.get(location_id) commtrack_user.clear_locations() commtrack_user.add_location(loc, create_sp_if_missing=True)
def location_fixture_generator(user, version, last_sync): 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()) 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)) 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 bootstrap_user( setup, username=TEST_USER, domain=TEST_DOMAIN, phone_number=TEST_NUMBER, password=TEST_PASSWORD, backend=TEST_BACKEND, first_name='', last_name='', home_loc=None, user_data=None, ): user_data = user_data or {} user = CommTrackUser.create(domain, username, password, phone_numbers=[TEST_NUMBER], user_data=user_data, first_name=first_name, last_name=last_name) if home_loc == setup.loc.site_code: if not SupplyPointCase.get_by_location(setup.loc): make_supply_point(domain, setup.loc) user.add_location(setup.loc) user.save() user.save_verified_number(domain, phone_number, verified=True, backend_id=backend) return CommTrackUser.wrap(user.to_json())
def save(self, user): commtrack_user = CommTrackUser.wrap(user.to_json()) location_id = self.cleaned_data['supply_point'] if location_id: loc = Location.get(location_id) commtrack_user.clear_locations() commtrack_user.add_location(loc)
def location_fixture_generator(user, version, last_sync): 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()) 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)) 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 __init__(self, domain, v): self.domain = domain self.v = v self.location = None u = v.owner if domain.commtrack_enabled: # currently only support one location on the UI linked_loc = CommTrackUser.wrap(u.to_json()).location if linked_loc: self.location = get_supply_point(self.domain.name, loc=linked_loc)['case'] self.C = domain.commtrack_settings
def save(self, user): commtrack_user = CommTrackUser.wrap(user.to_json()) location_id = self.cleaned_data['supply_point'] if location_id: loc = Location.get(location_id) commtrack_user.clear_locations() commtrack_user.add_location(loc, create_sp_if_missing=True) # add the supply point case id to user data fields # so that the phone can auto select supply_point = SupplyPointCase.get_by_location(loc) user.user_data['commtrack-supply-point'] = supply_point._id
def setUp(self): super(UserLocMapTest, self).setUp() self.user = CommCareUser.create(self.domain.name, 'commcareuser', 'password', phone_numbers=['123123'], user_data={}, first_name='test', last_name='user') self.ct_user = CommTrackUser.wrap(self.user.to_json()) self.loc = make_loc('secondloc') self.sp = make_supply_point(self.domain.name, self.loc) self.cache = LocationCache() self.mapping = UserLocMapping(self.user.username, self.user.domain, self.cache)
def __init__(self, domain, v): self.domain = domain self.v = v self.location = None u = v.owner if domain.commtrack_enabled: # if user is not actually a user, we let someone else process if not isinstance(u, CouchUser): raise NotAUserClassError # currently only support one location on the UI linked_loc = CommTrackUser.wrap(u.to_json()).location if linked_loc: self.location = get_supply_point(self.domain.name, loc=linked_loc) self.C = domain.commtrack_settings
def setUp(self): super(UserLocMapTest, self).setUp() self.user = CommCareUser.create( self.domain.name, 'commcareuser', 'password', phone_numbers=['123123'], user_data={}, first_name='test', last_name='user' ) self.ct_user = CommTrackUser.wrap(self.user.to_json()) self.loc = make_loc('secondloc') self.sp = make_supply_point(self.domain, self.loc) self.cache = LocationCache() self.mapping = UserLocMapping(self.user.username, self.user.domain, self.cache)
def test_location_migration(self): user = CommCareUser.create( self.domain.name, 'commcareuser', 'password', phone_numbers=['123123'], user_data={}, first_name='test', last_name='user' ) loc = make_loc('someloc') make_supply_point(self.domain.name, loc) user.commtrack_location = loc._id ct_user = CommTrackUser.wrap(user.to_json()) self.assertEqual(1, len(ct_user.locations)) self.assertEqual('someloc', ct_user.locations[0].name) self.assertFalse(hasattr(ct_user, 'commtrack_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 save(self): """ Calculate which locations need added or removed, then submit one caseblock to handle this """ user = CommTrackUser.get_by_username(self.username) if not user: raise UserUploadError( _('no username with {} found!'.format(self.username))) # have to rewrap since we need to force it to a commtrack user user = CommTrackUser.wrap(user.to_json()) current_locations = user.locations current_location_codes = [loc.site_code for loc in current_locations] commit_list = {} messages = [] def _add_loc(loc, clear=False): sp = self.get_supply_point_from_location(loc) if sp is None: messages.append( _("No supply point found for location '{}'. " "Make sure the location type is not set to administrative only " "and that the location has a valid sms code.").format( loc or '')) else: commit_list.update(user.supply_point_index_mapping(sp, clear)) for loc in self.to_add: if loc not in current_location_codes: _add_loc(loc) for loc in self.to_remove: if loc in current_location_codes: _add_loc(loc, clear=True) if commit_list: submit_mapping_case_block(user, commit_list) return messages
def save(self): """ Calculate which locations need added or removed, then submit one caseblock to handle this """ user = CommTrackUser.wrap(CommTrackUser.get_by_username(self.username).to_json()) current_locations = user.locations current_location_codes = [loc.site_code for loc in current_locations] commit_list = {} for loc in self.to_add: if loc not in current_location_codes: sp = self.get_supply_point_from_location(loc) commit_list.update(user.supply_point_index_mapping(sp)) for loc in self.to_remove: if loc in current_location_codes: sp = self.get_supply_point_from_location(loc) commit_list.update(user.supply_point_index_mapping(sp, True)) if commit_list: submit_mapping_case_block(user, commit_list)
def save(self): """ Calculate which locations need added or removed, then submit one caseblock to handle this """ user = CommTrackUser.get_by_username(self.username) if not user: raise UserUploadError(_('no username with {} found!'.format(self.username))) # have to rewrap since we need to force it to a commtrack user user = CommTrackUser.wrap(user.to_json()) current_locations = user.locations current_location_codes = [loc.site_code for loc in current_locations] commit_list = {} messages = [] def _add_loc(loc, clear=False): sp = self.get_supply_point_from_location(loc) if sp is None: messages.append(_("No supply point found for location '{}'. " "Make sure the location type is not set to administrative only " "and that the location has a valid sms code." ).format(loc or '')) else: commit_list.update(user.supply_point_index_mapping(sp, clear)) for loc in self.to_add: if loc not in current_location_codes: _add_loc(loc) for loc in self.to_remove: if loc in current_location_codes: _add_loc(loc, clear=True) if commit_list: submit_mapping_case_block(user, commit_list) return messages
def bootstrap_user(setup, username=TEST_USER, domain=TEST_DOMAIN, phone_number=TEST_NUMBER, password=TEST_PASSWORD, backend=TEST_BACKEND, first_name='', last_name='', home_loc=None, user_data=None, ): user_data = user_data or {} user = CommTrackUser.create( domain, username, password, phone_numbers=[TEST_NUMBER], user_data=user_data, first_name=first_name, last_name=last_name ) if home_loc == setup.loc.site_code: if not SupplyPointCase.get_by_location(setup.loc): make_supply_point(domain, setup.loc) user.add_location(setup.loc) user.save() user.save_verified_number(domain, phone_number, verified=True, backend_id=backend) return CommTrackUser.wrap(user.to_json())
def add_location(user, location_id): commtrack_user = CommTrackUser.wrap(user.to_json()) if location_id: loc = Location.get(location_id) commtrack_user.clear_locations() commtrack_user.add_location(loc, create_sp_if_missing=True)