Exemplo n.º 1
0
def load_memoizer(domain):
    group_memoizer = GroupMemoizer(domain=domain)
    # load groups manually instead of calling group_memoizer.load_all()
    # so that we can detect blank groups
    blank_groups = set()
    for group in Group.by_domain(domain):
        if group.name:
            group_memoizer.add_group(group)
        else:
            blank_groups.add(group)
    if blank_groups:
        raise GroupNameError(blank_groups=blank_groups)

    return group_memoizer
Exemplo n.º 2
0
def _run_fixture_upload(domain, workbook, replace=False, task=None):
    from corehq.apps.user_importer.importer import GroupMemoizer
    return_val = FixtureUploadResult()
    group_memoizer = GroupMemoizer(domain)
    get_location = get_memoized_location_getter(domain)
    data_types = []

    type_sheets = workbook.get_all_type_sheets()
    total_tables = len(type_sheets)
    return_val.number_of_fixtures = total_tables

    def _update_progress(table_count, item_count, items_in_table):
        if task:
            processed = table_count * 10 + (10 * item_count / items_in_table)
            DownloadBase.set_progress(task, processed, 10 * total_tables)

    with CouchTransaction() as transaction:
        for table_number, table_def in enumerate(type_sheets):
            data_type, delete, err = _create_data_type(domain, table_def, replace, transaction)
            return_val.errors.extend(err)
            if delete:
                continue
            transaction.save(data_type)
            data_types.append(data_type)

            data_items = list(workbook.get_data_sheet(data_type.tag))
            items_in_table = len(data_items)
            for sort_key, di in enumerate(data_items):
                _update_progress(table_number, sort_key, items_in_table)
                type_fields = data_type.fields
                item_fields = {
                    field.field_name: _process_item_field(field, di)
                    for field in type_fields
                }

                item_attributes = di.get('property', {})
                old_data_item, delete, err = _process_data_item(
                    domain, replace, data_type, di, item_fields, item_attributes, sort_key)
                return_val.errors.extend(err)
                if delete:
                    old_data_item.recursive_delete(transaction)
                    continue
                transaction.save(old_data_item)

                err = _process_group_ownership(di, old_data_item, group_memoizer, transaction)
                return_val.errors.extend(err)

                err = _process_user_ownership(di, old_data_item, transaction)
                return_val.errors.extend(err)

                err = _process_location_ownership(di, old_data_item, get_location, transaction)
                return_val.errors.extend(err)

    clear_fixture_quickcache(domain, data_types)
    clear_fixture_cache(domain)
    return return_val
Exemplo n.º 3
0
    def setUpClass(cls):
        super().setUpClass()
        cls.domain_obj = create_domain(cls.domain)

        # APP_USER_PROFILES is on ENTERPRISE and above
        cls.setup_subscription(cls.domain, SoftwarePlanEdition.ENTERPRISE)

        cls.group_memoizer = GroupMemoizer(domain=cls.domain_obj.name)
        cls.group_memoizer.load_all()

        cls.definition = CustomDataFieldsDefinition(
            domain=cls.domain_obj.name, field_type=UserFieldsView.field_type)
        cls.definition.save()
        cls.definition.set_fields([
            Field(
                slug='born',
                label='Year of Birth',
            ),
            Field(
                slug='_type',
                label='Type',
                choices=['fiction', 'non-fiction'],
            ),
        ])
        cls.definition.save()

        cls.profile = CustomDataFieldsProfile(
            name='Novelist',
            fields={'_type': 'fiction'},
            definition=cls.definition,
        )
        cls.profile.save()

        cls.user1 = CommCareUser.create(cls.domain_obj.name,
                                        'edith',
                                        'badpassword',
                                        None,
                                        None,
                                        first_name='Edith',
                                        last_name='Wharton',
                                        metadata={'born': 1862})
        cls.user2 = CommCareUser.create(
            cls.domain_obj.name,
            'george',
            'anotherbadpassword',
            None,
            None,
            first_name='George',
            last_name='Eliot',
            metadata={
                'born': 1849,
                PROFILE_SLUG: cls.profile.id
            },
        )
Exemplo n.º 4
0
 def test_download(self):
     user = CommCareUser.create(
         self.domain_obj.name,
         'edith',
         'badpassword',
         None,
         None,
         first_name='Edith',
         last_name='Wharton',
     )
     self.addCleanup(user.delete, deleted_by=None)
     group_memoizer = GroupMemoizer(domain=self.domain_obj.name)
     group_memoizer.load_all()
     (headers, rows) = parse_users(group_memoizer, self.domain_obj.name, {})
     rows = list(rows)
     self.assertEqual(1, len(rows))
     spec = dict(zip(headers, rows[0]))
     self.assertEqual('edith', spec['username'])
     self.assertTrue(re.search(r'^\*+$', spec['password']))
     self.assertEqual('True', spec['is_active'])
     self.assertEqual('Edith Wharton', spec['name'])
     self.assertTrue(spec['registered_on (read only)'].startswith(
         datetime.today().strftime("%Y-%m-%d")))