Example #1
0
    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))
Example #2
0
 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])
Example #3
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)
Example #5
0
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)))
Example #6
0
    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)
Example #8
0
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()
Example #9
0
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))
Example #11
0
    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()
Example #12
0
    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()
Example #13
0
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()
Example #14
0
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
        )
Example #15
0
 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)
Example #16
0
 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])
Example #17
0
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)
Example #18
0
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()
Example #19
0
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
Example #20
0
    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)))
Example #21
0
 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)
Example #22
0
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']
Example #23
0
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()
Example #24
0
 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)
     )
Example #25
0
 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
Example #26
0
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)
Example #27
0
 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
Example #29
0
 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
Example #30
0
    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)
Example #31
0
    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)
Example #32
0
    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
Example #33
0
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]))
Example #34
0
 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
Example #35
0
    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
Example #36
0
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))
Example #37
0
    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
Example #38
0
    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
Example #39
0
 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)
Example #40
0
    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()
Example #41
0
    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)
Example #44
0
 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
Example #45
0
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,
    )
Example #46
0
 def obj_get_list(self, bundle, domain, **kwargs):
     groups = Group.by_domain(domain)
     return groups
Example #47
0
 def get_from_group(name):
     group = Group.by_name(domain, name, one=True)
     return getattr(group, 'get_id', None)
Example #48
0
    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)
Example #49
0
 def options(self):
     return [(group.get_id, group.name)
             for group in Group.get_reporting_groups(self.domain)]
Example #50
0
 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))
Example #51
0
 def load_all(self):
     if not self.loaded:
         for group in Group.by_domain(self.domain):
             self.add_group(group)
         self.loaded = True
Example #52
0
 def save_all(self):
     Group.bulk_save(self.groups)
Example #53
0
 def create(self, domain, name):
     group = Group(domain=domain, name=name)
     self.add_group(group)
     return group
Example #54
0
                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
Example #55
0
 def test_group_reindexer(self):
     group = Group(domain=DOMAIN, name='g1')
     group.save()
     reindex_and_clean('group')
     self._assert_group_in_es(group)
Example #56
0
 def _get_group(self):
     group = self.cleaned_data['group']
     if group:
         return Group.get(group)
Example #57
0
 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]
Example #58
0
 def _owning_group(self):
     try:
         return Group.get(self.owner_id)
     except ResourceNotFound:
         return None
Example #59
0
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
Example #60
0
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)