def testGroupFilters(self): domain = "case-export-test" active_user = CommCareUser.create(domain=domain, username="******", password="******") inactive_user = CommCareUser.create(domain=domain, username="******", password="******") inactive_user.is_active = False inactive_user.save() group = Group(domain=domain, name="group", users=[active_user._id, inactive_user._id]) group.save() # no matter what the group should match on ownerid (but not user id) self.assertTrue(case_group_filter(_mock_case(group._id, "nobody"), group)) self.assertTrue(case_group_filter(_mock_case(group._id, active_user._id), group)) self.assertTrue(case_group_filter(_mock_case(group._id, inactive_user._id), group)) self.assertFalse(case_group_filter(_mock_case("nobody", group._id), group)) # test active users count self.assertTrue(case_group_filter(_mock_case(active_user._id, "nobody"), group)) self.assertTrue(case_group_filter(_mock_case("nobody", active_user._id), group)) self.assertTrue(case_group_filter(_mock_case(active_user._id, active_user._id), group)) # test inactive users don't count self.assertFalse(case_group_filter(_mock_case(inactive_user._id, "nobody"), group)) self.assertFalse(case_group_filter(_mock_case("nobody", inactive_user._id), group)) self.assertFalse(case_group_filter(_mock_case(inactive_user._id, inactive_user._id), group)) # combinations of active and inactive should count self.assertTrue(case_group_filter(_mock_case(active_user._id, inactive_user._id), group)) self.assertTrue(case_group_filter(_mock_case(inactive_user._id, active_user._id), group)) # duh self.assertFalse(case_group_filter(_mock_case("nobody", "nobody-else"), group))
def test_non_case_sharing_groups_not_included(self): user = self._mock_user('test-user-3') group = Group(domain='test-domain', users=['test-user-3'], case_sharing=False) group.save() ids = user.get_owner_ids() self.assertEqual(1, len(ids)) self.assertEqual(user._id, ids[0])
def test_update(self): self.client.login(username=self.username, password=self.password) group = Group({"name": "test", "domain": self.domain.name}) group.save() group_json = { "case_sharing": True, "metadata": { "localization": "Ghana" }, "name": "test group", "reporting": True, } backend_id = group._id response = self.client.put(self.single_endpoint(backend_id), simplejson.dumps(group_json), content_type='application/json') self.assertEqual(response.status_code, 204, response.content) self.assertEqual(1, len(Group.by_domain(self.domain.name))) modified = Group.get(backend_id) self.assertEqual(modified.name, "test group") self.assertTrue(modified.reporting) self.assertTrue(modified.case_sharing) self.assertEqual(modified.metadata["localization"], "Ghana") modified.delete()
def setUpClass(cls): case_pillow = CasePillow(online=False) group_pillow = GroupPillow(online=False) cls.pillows = [case_pillow, group_pillow] with trap_extra_setup(ConnectionError, msg="cannot connect to elasicsearch"): for pillow in cls.pillows: completely_initialize_pillow_index(pillow) case = new_case(closed=True) case_pillow.send_robust(case.to_json()) case = new_case(closed=False) case_pillow.send_robust(case.to_json()) case = new_case(closed=True, owner_id="foo") case_pillow.send_robust(case.to_json()) case = new_case(closed=False, owner_id="bar") case_pillow.send_robust(case.to_json()) group = Group(_id=uuid.uuid4().hex, users=["foo", "bar"]) cls.group_id = group.get_id group_pillow.send_robust(group.to_json()) for pillow in cls.pillows: pillow.get_es_new().indices.refresh(pillow.es_index)
def add_group(request, domain): group_name = request.POST['group_name'] group = Group.view("groups/by_name", key=group_name) if not group: group = Group(name=group_name, domain=domain) group.save() return HttpResponseRedirect(reverse("group_members", args=(domain, group.get_id)))
def test_update(self): group = Group({"name": "test", "domain": self.domain.name}) group.save() self.addCleanup(group.delete) group_json = { "case_sharing": True, "metadata": { "localization": "Ghana" }, "name": "test group", "reporting": True, } backend_id = group._id response = self._assert_auth_post_resource(self.single_endpoint(backend_id), json.dumps(group_json), content_type='application/json', method='PUT') self.assertEqual(response.status_code, 200, response.content) self.assertEqual(1, len(Group.by_domain(self.domain.name))) modified = Group.get(backend_id) self.assertEqual(modified.name, "test group") self.assertTrue(modified.reporting) self.assertTrue(modified.case_sharing) self.assertEqual(modified.metadata["localization"], "Ghana")
def setUpClass(cls): case_pillow = CasePillow(online=False) group_pillow = GroupPillow(online=False) cls.pillows = [case_pillow, group_pillow] for pillow in cls.pillows: completely_initialize_pillow_index(pillow) case = new_case(closed=True) case_pillow.send_robust(case.to_json()) case = new_case(closed=False) case_pillow.send_robust(case.to_json()) case = new_case(closed=True, owner_id="foo") case_pillow.send_robust(case.to_json()) case = new_case(closed=False, owner_id="bar") case_pillow.send_robust(case.to_json()) group = Group(_id=uuid.uuid4().hex, users=["foo", "bar"]) cls.group_id = group.get_id group_pillow.send_robust(group.to_json()) for pillow in cls.pillows: pillow.get_es_new().indices.refresh(pillow.es_index)
def edit_group(request, domain, group_id): group = Group.get(group_id) if group.domain == domain: name = request.POST.get('name') case_sharing = request.POST.get('case_sharing') reporting = request.POST.get('reporting') if name is not None and group.name != name: dupe = Group.by_name(domain, name, one=False).first() if dupe: messages.warning(request, _( "We didn't rename your group because there's already " "another group with that name." )) else: group.name = name if case_sharing in ('true', 'false'): group.case_sharing = json.loads(case_sharing) if reporting in ('true', 'false'): group.reporting = json.loads(reporting) group.save() return HttpResponseRedirect( reverse("group_members", args=[domain, group_id]) ) else: return HttpResponseForbidden()
def create_export_filter(request, domain, export_type='form'): request_obj = request.POST if request.method == 'POST' else request.GET from corehq.apps.reports.filters.users import UserTypeFilter app_id = request_obj.get('app_id', None) user_filters, use_user_filters = UserTypeFilter.get_user_filter(request) use_user_filters &= bool(user_filters) group = None if use_user_filters else get_group(**json_request(request_obj)) if export_type == 'case': if use_user_filters: groups = [g.get_id for g in Group.get_case_sharing_groups(domain)] filtered_users = users_matching_filter(domain, user_filters) filter = SerializableFunction(case_users_filter, users=filtered_users, groups=groups) else: filter = SerializableFunction(case_group_filter, group=group) else: filter = SerializableFunction(app_export_filter, app_id=app_id) datespan = request.datespan if datespan.is_valid(): datespan.set_timezone(get_timezone_for_user(request.couch_user, domain)) filter &= SerializableFunction(datespan_export_filter, datespan=datespan) if use_user_filters: groups = [g.get_id for g in Group.get_case_sharing_groups(domain)] filtered_users = users_matching_filter(domain, user_filters) filter &= SerializableFunction(users_filter, users=filtered_users) else: filter &= SerializableFunction(group_filter, group=group) return filter
def testGroupFilters(self): domain = 'case-export-test' active_user = CommCareUser.create(domain=domain, username='******', password='******') inactive_user = CommCareUser.create(domain=domain, username='******', password='******') inactive_user.is_active = False inactive_user.save() group = Group(domain=domain, name='group', users=[active_user._id, inactive_user._id]) group.save() # no matter what the group should match on ownerid (but not user id) self.assertTrue(case_group_filter(_mock_case(group._id, 'nobody'), group)) self.assertTrue(case_group_filter(_mock_case(group._id, active_user._id), group)) self.assertTrue(case_group_filter(_mock_case(group._id, inactive_user._id), group)) self.assertFalse(case_group_filter(_mock_case('nobody', group._id), group)) # test active users count self.assertTrue(case_group_filter(_mock_case(active_user._id, 'nobody'), group)) self.assertTrue(case_group_filter(_mock_case('nobody', active_user._id), group)) self.assertTrue(case_group_filter(_mock_case(active_user._id, active_user._id), group)) # test inactive users don't count self.assertFalse(case_group_filter(_mock_case(inactive_user._id, 'nobody'), group)) self.assertFalse(case_group_filter(_mock_case('nobody', inactive_user._id), group)) self.assertFalse(case_group_filter(_mock_case(inactive_user._id, inactive_user._id), group)) # combinations of active and inactive should count self.assertTrue(case_group_filter(_mock_case(active_user._id, inactive_user._id), group)) self.assertTrue(case_group_filter(_mock_case(inactive_user._id, active_user._id), group)) # duh self.assertFalse(case_group_filter(_mock_case('nobody', 'nobody-else'), group))
def test_create(self): self.client.login(username=self.username, password=self.password) group = Group({"name": "test"}) group.save() self.assertEqual(0, len(CommCareUser.by_domain(self.domain.name))) user_json = { "username": "******", "password": "******", "first_name": "John", "last_name": "Doe", "email": "*****@*****.**", "language": "en", "phone_numbers": ["+50253311399", "50253314588"], "groups": [group._id], "user_data": {"chw_id": "13/43/DFA"}, } response = self.client.post(self.list_endpoint, json.dumps(user_json), content_type="application/json") self.assertEqual(response.status_code, 201) [user_back] = CommCareUser.by_domain(self.domain.name) self.assertEqual(user_back.username, "jdoe") self.assertEqual(user_back.first_name, "John") self.assertEqual(user_back.last_name, "Doe") self.assertEqual(user_back.email, "*****@*****.**") self.assertEqual(user_back.language, "en") self.assertEqual(user_back.get_group_ids()[0], group._id) self.assertEqual(user_back.user_data["chw_id"], "13/43/DFA") self.assertEqual(user_back.default_phone_number, "50253311399") user_back.delete() group.delete()
def test_update(self): self.client.login(username=self.username, password=self.password) user = CommCareUser.create(domain=self.domain.name, username="******", password="******") group = Group({"name": "test"}) group.save() user_json = { "first_name": "test", "last_name": "last", "email": "*****@*****.**", "language": "pol", "phone_numbers": ["+50253311399", "50253314588"], "groups": [group._id], "user_data": {"chw_id": "13/43/DFA"}, } backend_id = user._id response = self.client.put( self.single_endpoint(backend_id), json.dumps(user_json), content_type="application/json" ) self.assertEqual(response.status_code, 200, response.content) self.assertEqual(1, len(CommCareUser.by_domain(self.domain.name))) modified = CommCareUser.get(backend_id) self.assertEqual(modified.username, "test") self.assertEqual(modified.first_name, "test") self.assertEqual(modified.last_name, "last") self.assertEqual(modified.email, "*****@*****.**") self.assertEqual(modified.language, "pol") self.assertEqual(modified.get_group_ids()[0], group._id) self.assertEqual(modified.user_data["chw_id"], "13/43/DFA") self.assertEqual(modified.default_phone_number, "50253311399") modified.delete() group.delete()
def edit_group(request, domain, group_id): group = Group.get(group_id) if group.domain == domain: name = request.POST.get("name") case_sharing = request.POST.get("case_sharing") reporting = request.POST.get("reporting") if not name: messages.warning( request, _("You tried to remove the group's name, " "but every group must have a name so we left it unchanged."), ) elif group.name != name: dupe = Group.by_name(domain, name, one=False).first() if dupe: messages.warning( request, _("We didn't rename your group because there's already " "another group with that name.") ) else: group.name = name if case_sharing in ("true", "false"): group.case_sharing = json.loads(case_sharing) if reporting in ("true", "false"): group.reporting = json.loads(reporting) group.save() return HttpResponseRedirect(reverse("group_members", args=[domain, group_id])) else: return HttpResponseForbidden()
class CommTrackTest(TestCase): requisitions_enabled = False # can be overridden user_definitions = [] def setUp(self): # might as well clean house before doing anything delete_all_xforms() delete_all_cases() delete_all_sync_logs() StockReport.objects.all().delete() StockTransaction.objects.all().delete() self.backend = test.bootstrap(TEST_BACKEND, to_console=True) self.domain = bootstrap_domain() bootstrap_location_types(self.domain.name) bootstrap_products(self.domain.name) self.ct_settings = CommtrackConfig.for_domain(self.domain.name) self.ct_settings.consumption_config = ConsumptionConfig( min_transactions=0, min_window=0, optimal_window=60, min_periods=0, ) if self.requisitions_enabled: self.ct_settings.requisition_config = get_default_requisition_config() self.ct_settings.save() self.domain = Domain.get(self.domain._id) self.loc = make_loc('loc1') self.sp = make_supply_point(self.domain.name, self.loc) self.users = [bootstrap_user(self, **user_def) for user_def in self.user_definitions] # everyone should be in a group. self.group = Group(domain=TEST_DOMAIN, name='commtrack-folks', users=[u._id for u in self.users], case_sharing=True) self.group.save() self.sp.owner_id = self.group._id self.sp.save() self.products = sorted(Product.by_domain(self.domain.name), key=lambda p: p._id) self.assertEqual(3, len(self.products)) def tearDown(self): SQLLocation.objects.all().delete() self.backend.delete() for u in self.users: u.delete() self.domain.delete() # domain delete cascades to everything else def get_commtrack_forms(self, domain): return XFormInstance.view('reports_forms/all_forms', startkey=['submission xmlns', domain, COMMTRACK_REPORT_XMLNS], endkey=['submission xmlns', domain, COMMTRACK_REPORT_XMLNS, {}], reduce=False, include_docs=True )
def test_yes_Z(self): date_string = '2014-08-26T15:20:20.062732Z' group = Group.wrap({'last_modified': date_string}) self.assertEqual(group.to_json()['last_modified'], date_string) date_string_no_usec = '2014-08-26T15:20:20Z' date_string_yes_usec = '2014-08-26T15:20:20.000000Z' group = Group.wrap({'last_modified': date_string_no_usec}) self.assertEqual(group.to_json()['last_modified'], date_string_yes_usec)
def test_case_sharing_groups_included(self): user = self._mock_user('test-user-2') group = Group(domain='test-domain', users=['test-user-2'], case_sharing=True) group.save() ids = user.get_owner_ids() self.assertEqual(2, len(ids)) self.assertEqual(user._id, ids[0]) self.assertEqual(group._id, ids[1])
class CallCenterCaseSharingTest(BaseCCTests): domain_name = 'cc_sharing' def setUp(self): super(CallCenterCaseSharingTest, self).setUp() self.domain = create_domain(self.domain_name) self.supervisor = CommCareUser.create(self.domain_name, 'supervisor@' + self.domain_name, '***') self.domain.call_center_config.enabled = True self.domain.call_center_config.case_owner_id = self.supervisor.get_id self.domain.call_center_config.case_type = 'cc_flw' self.domain.save() self.user = CommCareUser.create(self.domain_name, 'user@' + self.domain_name, '***') sync_call_center_user_case(self.user) self.group = Group( domain=self.domain_name, name='case sharing group', case_sharing=True, users=[self.user.user_id] ) self.group.save() load_data( self.domain_name, self.user.user_id, 'not this user', self.group.get_id, case_opened_by=self.user.user_id, case_closed_by=self.user.user_id) # create one case of each type so that we get the indicators where there is no data for the period create_cases_for_types(self.domain_name, ['person', 'dog']) def tearDown(self): super(CallCenterCaseSharingTest, self).tearDown() clear_data(self.domain.name) self.domain.delete() @run_with_all_backends def test_cases_owned_by_group(self): """ Ensure that indicators include cases owned by a case sharing group the user is part of. """ indicator_set = CallCenterIndicators( self.domain.name, self.domain.default_timezone, self.domain.call_center_config.case_type, self.supervisor, custom_cache=locmem_cache ) self.assertEqual(indicator_set.user_to_case_map.keys(), [self.user.get_id]) self.assertEqual(indicator_set.users_needing_data, set([self.user.get_id])) self.assertEqual(indicator_set.owners_needing_data, set([self.user.get_id, self.group.get_id])) expected = expected_standard_indicators() expected['totalCases'] = 0L # no cases with user_id = self.user.get_id self._test_indicators(self.user, indicator_set.get_data(), expected)
class CommTrackTest(TestCase): requisitions_enabled = False # can be overridden user_definitions = [] def setUp(self): super(CommTrackTest, self).setUp() # might as well clean house before doing anything delete_all_xforms() delete_all_cases() delete_all_sync_logs() StockReport.objects.all().delete() StockTransaction.objects.all().delete() self.backend, self.backend_mapping = setup_default_sms_test_backend() self.domain = bootstrap_domain(TEST_DOMAIN) bootstrap_location_types(self.domain.name) bootstrap_products(self.domain.name) self.ct_settings = CommtrackConfig.for_domain(self.domain.name) self.ct_settings.consumption_config = ConsumptionConfig( min_transactions=0, min_window=0, optimal_window=60, min_periods=0, ) # todo: remove? if self.requisitions_enabled: self.ct_settings.requisition_config = get_default_requisition_config() self.ct_settings.save() self.domain = Domain.get(self.domain._id) self.loc = make_loc('loc1') self.sp = self.loc.linked_supply_point() self.users = [bootstrap_user(self, **user_def) for user_def in self.user_definitions] # everyone should be in a group. self.group = Group(domain=TEST_DOMAIN, name='commtrack-folks', users=[u._id for u in self.users], case_sharing=True) self.group._id = self.sp.owner_id self.group.save() self.products = sorted(Product.by_domain(self.domain.name), key=lambda p: p._id) self.assertEqual(3, len(self.products)) def tearDown(self): SQLLocation.objects.all().delete() self.backend_mapping.delete() self.backend.delete() delete_all_xforms() delete_all_cases() delete_all_sync_logs() delete_all_users() self.domain.delete() # domain delete cascades to everything else super(CommTrackTest, self).tearDown()
def lookup_cbo_id_from_form_id(form_id): case = CommCareCase.get_by_xform_id(form_id).first() group = Group.by_user(case.user_id).one() # if the id doesn't belong to a user, maybe its a group? if not group: group = Group.get(case.user_id) return group.get_id
def test_delete_group(self): group = Group({"name": "test", "domain": self.domain.name}) group.save() self.addCleanup(group.delete) backend_id = group._id response = self._assert_auth_post_resource(self.single_endpoint(backend_id), '', method='DELETE') self.assertEqual(response.status_code, 204, response.content) self.assertEqual(0, len(Group.by_domain(self.domain.name)))
def setUp(self): self.domain = "TEST" # use Group just 'cause it's a simple model, # and I can't create new models within tests self.db = Group.get_db() self.groups = [] for i in range(11): group = Group(domain=self.domain, name="test{}".format(i), index=i) group.save() self.groups.append(group)
def group_name(owner_id): group = Group.by_user(owner_id, wrap=False, include_names=True) if not group: try: group = Group.get(owner_id) except ResourceNotFound: group = dict(name="No Group") if isinstance(group, list): group = group[0] return group['name']
def refresh_group_views(): from corehq.apps.groups.models import Group for view_name in [ 'groups/by_name', ]: Group.view( view_name, include_docs=False, limit=1, ).fetch()
def _get_groups(self): if self.request.couch_user.is_commcare_user(): groups = Group.by_user(self.request.couch_user) else: # for web users just show everything? groups = Group.by_domain(self.domain) return sorted( groups, key=lambda group: alphanumeric_sort_key(group.name) )
def create_group(self, name, users): group = Group( domain=self.domain, name=name, users=[user._id for user in users], case_sharing=True, ) group.save() self.groups.append(group) return group
class CallCenterCaseSharingTest(BaseCCTests): domain_name = 'cc_sharing' def setUp(self): super(CallCenterCaseSharingTest, self).setUp() self.domain = create_domain(self.domain_name) self.supervisor = CommCareUser.create(self.domain_name, 'supervisor@' + self.domain_name, '***') self.domain.call_center_config.enabled = True self.domain.call_center_config.case_owner_id = self.supervisor.get_id self.domain.call_center_config.case_type = 'cc_flw' self.domain.save() self.user = CommCareUser.create(self.domain_name, 'user@' + self.domain_name, '***') sync_call_center_user_case(self.user) self.group = Group( domain=self.domain_name, name='case sharing group', case_sharing=True, users=[self.user.user_id] ) self.group.save() load_data( self.domain_name, self.user.user_id, 'not this user', self.group.get_id, case_opened_by=self.user.user_id, case_closed_by=self.user.user_id) def tearDown(self): super(CallCenterCaseSharingTest, self).tearDown() clear_data(self.domain.name) self.domain.delete() @run_with_all_backends @patch('corehq.apps.callcenter.indicator_sets.get_case_types_for_domain_es', return_value={'person', 'dog', CASE_TYPE}) def test_cases_owned_by_group(self, mock): # Ensure that indicators include cases owned by a case sharing group the user is part of. indicator_set = CallCenterIndicators( self.domain.name, self.domain.default_timezone, self.domain.call_center_config.case_type, self.supervisor, custom_cache=locmem_cache ) self.assertEqual(list(indicator_set.user_to_case_map), [self.user.get_id]) self.assertEqual(indicator_set.users_needing_data, set([self.user.get_id])) self.assertEqual(indicator_set.owners_needing_data, set([self.user.get_id, self.group.get_id])) expected = expected_standard_indicators() expected['totalCases'] = 0 # no cases with user_id = self.user.get_id self._test_indicators(self.user, indicator_set.get_data(), expected)
def test_no_Z(self): date_string_no_Z = '2014-08-26T15:20:20.062732' date_string_yes_Z = '2014-08-26T15:20:20.062732Z' group = Group.wrap({'last_modified': date_string_no_Z}) self.assertEqual(group.to_json()['last_modified'], date_string_yes_Z) # iso_format can, technically, produce this if microseconds # happens to be exactly 0 date_string_no_Z = '2014-08-26T15:20:20' date_string_yes_Z = '2014-08-26T15:20:20.000000Z' group = Group.wrap({'last_modified': date_string_no_Z}) self.assertEqual(group.to_json()['last_modified'], date_string_yes_Z)
def _send_group_to_es(self, _id=None): group = Group( domain=self.domain, name=self.group_name, case_sharing=self.case_sharing, reporting=self.reporting, _id=_id or uuid.uuid4().hex, ) self.pillow.change_transport(group.to_json()) self.pillow.get_es_new().indices.refresh(self.pillow.es_index) return group
def _send_group_to_es(self, _id=None): group = Group( domain=self.domain, name=self.group_name, case_sharing=self.case_sharing, reporting=self.reporting, _id=_id or uuid.uuid4().hex, ) send_to_elasticsearch('groups', group.to_json()) self.es.indices.refresh(GROUP_INDEX_INFO.index) return group
def test_get_single(self): self.client.login(username=self.username, password=self.password) group = Group({"name": "test", "domain": self.domain.name}) group.save() backend_id = group.get_id response = self.client.get(self.single_endpoint(backend_id)) self.assertEqual(response.status_code, 200) api_groups = simplejson.loads(response.content) self.assertEqual(api_groups['id'], backend_id)
def setUpClass(cls): super(TemplatingTestCase, cls).setUpClass() cls.domain = 'templating-test' cls.domain_obj = Domain(name=cls.domain) cls.domain_obj.save() cls.mobile_user = CommCareUser.create(cls.domain, 'mobile1@templating-test', '12345', None, None, first_name='Mobile', last_name='User') cls.mobile_user.add_phone_number('999123') cls.mobile_user.save() cls.web_user = WebUser.create(cls.domain, 'web1@templating-test', '12345', created_by=None, created_via=None, first_name='Web', last_name='User') cls.web_user.add_phone_number('999456') cls.web_user.save() cls.group = Group(domain=cls.domain, name='Test Group') cls.group.save() cls.location_type = LocationType.objects.create(domain=cls.domain, name='top-level', code='top-level') cls.location = SQLLocation.objects.create( domain=cls.domain, name='Test Location', site_code='loc1234', location_type=cls.location_type)
def __init__(self, *args, **kwargs): user = kwargs.pop('user', None) domain = kwargs.pop('domain', None) super(DomainMetadataForm, self).__init__(*args, **kwargs) if not (user and user.is_previewer): # commtrack is pre-release self.fields['commtrack_enabled'].widget = forms.HiddenInput() if domain is not None: groups = Group.get_case_sharing_groups(domain) users = CommCareUser.by_domain(domain) domain_owner_choices = [(group._id, group.name) for group in groups] domain_user_choices = [(user._id, user.raw_username) for user in users] domain_owner_choices += domain_user_choices self.fields[ "sms_case_registration_owner_id"].choices = domain_owner_choices self.fields[ "sms_case_registration_user_id"].choices = domain_user_choices
def _update_group_membership(request, domain, group_id): group = Group.get(group_id) if group.domain != domain: return HttpResponseForbidden() selected_users = request.POST.getlist('selected_ids') # check to make sure no users were deleted at time of making group users = iter_docs(CouchUser.get_db(), selected_users) safe_users = [ CouchUser.wrap_correctly(user) for user in users if user['doc_type'] == 'CommCareUser' and user.get('domain') == domain ] safe_ids = [user.user_id for user in safe_users] group.set_user_ids(safe_ids) _ensure_case_sharing_privilege(request, group) group.save() messages.success(request, _("Group %s updated!") % group.name) return HttpResponseRedirect(reverse("group_members", args=[domain, group_id]))
def _update(self, bundle): should_save = False for key, value in bundle.data.items(): if key == 'name' and getattr(bundle.obj, key, None) != value: if not Group.by_name(bundle.obj.domain, value): setattr(bundle.obj, key, value or '') should_save = True else: raise Exception("A group with this name already exists") if key == 'users' and getattr(bundle.obj, key, None) != value: users_to_add = set(value) - set(bundle.obj.users) users_to_remove = set(bundle.obj.users) - set(value) for user in users_to_add: bundle.obj.add_user(user) should_save = True for user in users_to_remove: bundle.obj.remove_user(user) should_save = True elif getattr(bundle.obj, key, None) != value: setattr(bundle.obj, key, value) should_save = True return should_save
def rows(self): group_id = self.request.GET.get("group", None) month = self.request.GET.get("month", None) year = self.request.GET.get("year", None) curval = float(self.request.GET.get("curval", 1.0)) curname = self.request.GET.get("curname", "MK") if not (month and year): return [] if group_id: group = Group.get(group_id) group_name = group.name users = group.users else: users = map(lambda x: x._id, CommCareUser.by_domain(self.domain)) group_name = "Everybody" lg = LendingGroupAggregate(group_name, users, month, year, curval, curname) rows = [] for r in self._rows: if r: row = [r[0]] def _ga(x): if x: r = getattr(lg, x) else: r = '' return r row.extend(map(_ga, r[1:])) rows.append(row) else: rows.append(['<hr />']) return rows
def generate_case_export_payload(domain, include_closed, format, group, user_filter, process=None): """ Returns a FileWrapper object, which only the file backend in django-soil supports """ status = 'all' if include_closed else 'open' case_ids = CommCareCase.get_all_cases(domain, status=status, wrapper=lambda r: r['id']) class stream_cases(object): def __init__(self, all_case_ids): self.all_case_ids = all_case_ids def __iter__(self): for case_ids in chunked(self.all_case_ids, 500): for case in wrapped_docs(CommCareCase, case_ids): yield case def __len__(self): return len(self.all_case_ids) # todo deal with cached user dict here users = get_all_users_by_domain(domain, group=group, user_filter=user_filter) groups = Group.get_case_sharing_groups(domain) fd, path = tempfile.mkstemp() with os.fdopen(fd, 'wb') as file: workbook = WorkBook(file, format) export_cases_and_referrals( domain, stream_cases(case_ids), workbook, users=users, groups=groups, process=process ) export_users(users, workbook) workbook.close() return FileWrapper(open(path))
def setUpClass(cls): cls.domain = 'message-formatting-test' cls.domain_obj = Domain(name=cls.domain) cls.domain_obj.save() cls.mobile_user = CommCareUser.create( cls.domain, 'mobile1@message-formatting-test', '12345', first_name='Mobile', last_name='User' ) cls.web_user = WebUser.create( cls.domain, 'web1@message-formatting-test', '12345', first_name='Web', last_name='User' ) cls.group = Group(domain=cls.domain, name='Test Group') cls.group.save() cls.location_type = LocationType.objects.create( domain=cls.domain, name='top-level', code='top-level' ) cls.location = SQLLocation.objects.create( domain=cls.domain, name='Test Location', site_code='loc1234', location_type=cls.location_type ) cls.couch_location = cls.location.couch_location
def get_case_filter(self): group = self._get_group() if group: user_ids = set(group.get_static_user_ids()) case_filter = [OR( OwnerFilter(group._id), OwnerFilter(user_ids), LastModifiedByFilter(user_ids) )] else: case_sharing_groups = [g.get_id for g in Group.get_case_sharing_groups(self.domain_object.name)] case_filter = [OR( OwnerTypeFilter(self._get_es_user_types()), OwnerFilter(case_sharing_groups), LastModifiedByFilter(case_sharing_groups) )] date_filter = self._get_datespan_filter() if date_filter: case_filter.append(date_filter) return case_filter
def report_context(self): ward = self.request.GET.get("group", None) month = self.request.GET.get("month", None) year = self.request.GET.get("year", None) if not (ward and month and year): return dict() ward = Group.get(ward) #provs = retrieve_providers(self.domain, ward) provs = map(CommCareUser.get, ward.users) prov_p = {} # Providers, indexed by name. refs_p = {} # Referrals, indexed by name. for p in provs: x = retrieve_patient_group( get_patients_by_provider(self.domain, p._id), self.domain, year, month) prov_p[p.get_id] = x refs_p[p.get_id] = sum([a['referrals_completed'] for a in x]) return dict(ward=ward, year=year, month=month, provs=provs, prov_p=prov_p, refs_p=refs_p)
def test_update(self): self.client.login(username=self.username, password=self.password) user = CommCareUser.create(domain=self.domain.name, username="******", password="******") group = Group({"name": "test"}) group.save() user_json = { "first_name": "test", "last_name": "last", "email": "*****@*****.**", "language": "pol", "phone_numbers": [ "+50253311399", "50253314588" ], "groups": [ group._id ], "user_data": { "chw_id": "13/43/DFA" } } backend_id = user._id response = self.client.put(self.single_endpoint(backend_id), simplejson.dumps(user_json), content_type='application/json') self.assertEqual(response.status_code, 202, response.content) self.assertEqual(1, len(CommCareUser.by_domain(self.domain.name))) modified = CommCareUser.get(backend_id) self.assertEqual(modified.username, "test") self.assertEqual(modified.first_name, "test") self.assertEqual(modified.last_name, "last") self.assertEqual(modified.email, "*****@*****.**") self.assertEqual(modified.language, "pol") self.assertEqual(modified.get_group_ids()[0], group._id) self.assertEqual(modified.user_data["chw_id"], "13/43/DFA") self.assertEqual(modified.default_phone_number, "+50253311399") modified.delete() group.delete()
def test_create(self): self.client.login(username=self.username, password=self.password) group = Group({"name": "test"}) group.save() self.assertEqual(0, len(CommCareUser.by_domain(self.domain.name))) user_json = { "username": "******", "password": "******", "first_name": "John", "last_name": "Doe", "email": "*****@*****.**", "language": "en", "phone_numbers": [ "+50253311399", "50253314588" ], "groups": [ group._id ], "user_data": { "chw_id": "13/43/DFA" } } response = self.client.post(self.list_endpoint, simplejson.dumps(user_json), content_type='application/json') self.assertEqual(response.status_code, 201) [user_back] = CommCareUser.by_domain(self.domain.name) self.assertEqual(user_back.username, "jdoe") self.assertEqual(user_back.first_name, "John") self.assertEqual(user_back.last_name, "Doe") self.assertEqual(user_back.email, "*****@*****.**") self.assertEqual(user_back.language, "en") self.assertEqual(user_back.get_group_ids()[0], group._id) self.assertEqual(user_back.user_data["chw_id"], "13/43/DFA") self.assertEqual(user_back.default_phone_number, "+50253311399") user_back.delete() group.delete()
def handle(self, *args, **options): self.stdout.write("Processing groups...\n") relevant_ids = set([ r['id'] for r in Group.get_db().view( 'groups/all_groups', reduce=False, ).all() ]) to_save = [] for group in iter_docs(Group.get_db(), relevant_ids): if 'last_modified' not in group or not group['last_modified']: print group['_id'] group['last_modified'] = datetime.now().isoformat() to_save.append(group) if len(to_save) > 500: Group.get_db().bulk_save(to_save) to_save = [] if to_save: Group.get_db().bulk_save(to_save)
def test_kafka_group_pillow(self): domain = uuid.uuid4().hex user_id = uuid.uuid4().hex # make a group group = Group(domain=domain, name='g1', users=[user_id]) group.save() # send to kafka since = get_topic_offset(topics.GROUP) change_meta = change_meta_from_doc( document=group.to_json(), data_source_type=data_sources.SOURCE_COUCH, data_source_name=Group.get_db().dbname, ) producer.send_change(topics.GROUP, change_meta) # send to elasticsearch pillow = get_group_pillow() pillow.process_changes(since=since, forever=False) self.elasticsearch.indices.refresh(GROUP_INDEX_INFO.index) # verify there self._verify_group_in_es(group)
def options(self): options = [(group._id, "%s (Group)" % group.name) for group in Group.get_case_sharing_groups(self.domain)] user_options = super(SelectCaseOwnerFilter, self).options options.extend(user_options) return options
def _group_to_change_meta(group): return change_meta_from_doc( document=group, data_source_type=data_sources.SOURCE_COUCH, data_source_name=Group.get_db().dbname, )
def obj_get_list(self, bundle, domain, **kwargs): groups = Group.by_domain(domain) return groups
def get_from_group(name): group = Group.by_name(domain, name, one=True) return getattr(group, 'get_id', None)
def record_iter(self, start_datetime, end_datetime): group_ids = get_group_ids_by_last_modified(start_datetime, end_datetime) return iter_docs(Group.get_db(), group_ids)
def options(self): return [(group.get_id, group.name) for group in Group.get_reporting_groups(self.domain)]
def test_get_wrapped_group(self): group = Group(domain=self.domain, name='wrapped-group-test') group.save() self.addCleanup(group.delete) wrapped = get_wrapped_owner(group._id) self.assertTrue(isinstance(wrapped, Group))
def load_all(self): if not self.loaded: for group in Group.by_domain(self.domain): self.add_group(group) self.loaded = True
def save_all(self): Group.bulk_save(self.groups)
def create(self, domain, name): group = Group(domain=domain, name=name) self.add_group(group) return group
return None return user elif self.recipient_type == self.RECIPIENT_TYPE_CASE_GROUP: try: group = CommCareCaseGroup.get(self.recipient_id) except ResourceNotFound: return None if group.domain != self.domain: return None return group elif self.recipient_type == self.RECIPIENT_TYPE_USER_GROUP: try: group = Group.get(self.recipient_id) except ResourceNotFound: return None if group.domain != self.domain: return None return group elif self.recipient_type == self.RECIPIENT_TYPE_LOCATION: location = SQLLocation.by_location_id(self.recipient_id) if location is None: return None if location.domain != self.domain: return None
def test_group_reindexer(self): group = Group(domain=DOMAIN, name='g1') group.save() reindex_and_clean('group') self._assert_group_in_es(group)
def _get_group(self): group = self.cleaned_data['group'] if group: return Group.get(group)
def __init__(self, domain): self.domain = domain self.cati_group = Group.by_name(domain, const.CATI_GROUP_NAME) self.cati_users = self.cati_group.get_users() self.cati_user_ids = [cati_user._id for cati_user in self.cati_users]
def _owning_group(self): try: return Group.get(self.owner_id) except ResourceNotFound: return None
def get_user_ids_for_group(groups): users = [] for group_id in groups: group = Group.get(group_id) users.extend(group.get_user_ids()) return users
class CommTrackTest(TestCase): requisitions_enabled = False # can be overridden user_definitions = [] def setUp(self): # might as well clean house before doing anything delete_all_xforms() delete_all_cases() StockReport.objects.all().delete() StockTransaction.objects.all().delete() self.backend = test.bootstrap(TEST_BACKEND, to_console=True) self.domain = bootstrap_domain() self.ct_settings = CommtrackConfig.for_domain(self.domain.name) self.ct_settings.consumption_config = ConsumptionConfig( min_transactions=0, min_window=0, optimal_window=60, min_periods=0, ) if self.requisitions_enabled: self.ct_settings.requisition_config = get_default_requisition_config( ) self.ct_settings.save() self.domain = Domain.get(self.domain._id) self.loc = make_loc('loc1') self.sp = make_supply_point(self.domain.name, self.loc) self.users = [ bootstrap_user(self, **user_def) for user_def in self.user_definitions ] if False: # bootstrap additional users for requisitions # needs to get reinserted for requisition stuff later self.approver = bootstrap_user(self, **APPROVER_USER) self.packer = bootstrap_user(self, **PACKER_USER) self.users += [self.approver, self.packer] # everyone should be in a group. self.group = Group(domain=TEST_DOMAIN, name='commtrack-folks', users=[u._id for u in self.users], case_sharing=True) self.group.save() self.sp.owner_id = self.group._id self.sp.save() self.products = sorted(Product.by_domain(self.domain.name), key=lambda p: p._id) self.assertEqual(3, len(self.products)) def tearDown(self): self.backend.delete() for u in self.users: u.delete() self.domain.delete() # domain delete cascades to everything else def get_commtrack_forms(self, domain): return XFormInstance.view( 'reports_forms/all_forms', startkey=['submission xmlns', domain, COMMTRACK_REPORT_XMLNS], endkey=['submission xmlns', domain, COMMTRACK_REPORT_XMLNS, {}], reduce=False, include_docs=True)