Example #1
0
    def test_group_dictize_for_org_with_private_package_count_collaborator(
        self,
    ):
        import ckan.tests.helpers as helpers

        org_obj = factories.Organization.model()
        user_obj = factories.User.model()
        private_dataset = factories.Dataset(owner_org=org_obj.id, private=True)
        factories.Dataset(owner_org=org_obj.id)
        context = {
            "model": model,
            "session": model.Session,
            "auth_user_obj": user_obj,
        }
        org = model_dictize.group_dictize(org_obj, context)
        assert org["package_count"] == 1

        helpers.call_action(
            "package_collaborator_create",
            id=private_dataset["id"],
            user_id=user_obj.id,
            capacity="member",
        )
        org = model_dictize.group_dictize(org_obj, context)
        assert org["package_count"] == 2
Example #2
0
    def test_group_dictize_group_with_extra(self):
        group_obj = factories.Group.model(extras=[{"key": "k1", "value": "v1"}])
        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert group["extras"][0]["key"] == "k1"
def metadata_collection_dictize(metadata_collection, context):
    model = context['model']
    is_latest_revision = not (context.get('revision_id')
                              or context.get('revision_date'))
    execute = _execute if is_latest_revision else _execute_with_revision

    result_dict = ckan_model_dictize.group_dictize(
        metadata_collection,
        context,
        include_groups=False,
        include_tags=False,
        include_users=False,
        include_extras=True,
        packages_field='dataset_count')

    # infrastructures
    if is_latest_revision:
        member = model.member_table
    else:
        member = model.member_revision_table
    group = model.group_table
    q = select([group, member.c.capacity],
               from_obj=member.join(group, group.c.id == member.c.group_id)
               ).where(member.c.table_id == metadata_collection.id)\
                .where(member.c.state == 'active') \
                .where(group.c.is_organization == False) \
                .where(group.c.type == 'infrastructure')
    result = execute(q, member, context)
    context['with_capacity'] = False
    result_dict['infrastructures'] = ckan_model_dictize.group_list_dictize(
        result, context, with_package_counts=False)

    return result_dict
Example #4
0
File: get.py Project: slmnhq/ckan
def group_show(context, data_dict):
    '''Shows group details'''
    model = context['model']
    id = data_dict['id']

    group = model.Group.get(id)
    context['group'] = group

    if group is None:
        raise NotFound

    check_access('group_show',context, data_dict)

    group_dict = model_dictize.group_dictize(group, context)

    for item in plugins.PluginImplementations(plugins.IGroupController):
        item.read(group)

    group_plugin = lib_plugins.lookup_group_plugin(group_dict['type'])
    try:
        schema = group_plugin.db_to_form_schema_options({
            'type':'show',
            'api': 'api_version' in context,
            'context': context })
    except AttributeError:
        schema = group_plugin.db_to_form_schema()

    if schema:
        package_dict, errors = validate(group_dict, schema, context=context)

    return group_dict
Example #5
0
    def test_2_group_schema(self):

        group = model.Session.query(model.Group).first()

        data = group_dictize(group, self.context)

        converted_data, errors = validate(data, default_group_schema(), self.context)
        group_pack = sorted(group.packages, key=lambda x:x.id)

        converted_data["packages"] = sorted(converted_data["packages"], key=lambda x:x["id"])

        expected = {'description': u'These are books that David likes.',
                                 'id': group.id,
                                 'name': u'david',
                                 'packages': sorted([{'id': group_pack[0].id},
                                              {'id': group_pack[1].id,
                                               }], key=lambda x:x["id"]),
                                 'title': u"Dave's books"}


        assert not errors
        assert converted_data == expected, pformat(converted_data) + '\n\n' + pformat(expected)



        data["packages"].sort(key=lambda x:x["id"])
        data["packages"][0]["id"] = 'fjdlksajfalsf'
        data["packages"][1].pop("id")
        data["packages"][1].pop("name")

        converted_data, errors = validate(data, default_group_schema(), self.context)
        assert errors ==  {'packages': [{'id': [u'Dataset was not found.']}, {'id': [u'Missing value']}]} , pformat(errors)
    def test_16_group_dictized(self):

        context = {"model": model,
                  "session": model.Session}

        pkg = model.Session.query(model.Package).filter_by(name='annakarenina3').first()

        group_dict = {'name': 'help',
                      'title': 'help',
                      'extras': [{'key': 'genre', 'value': u'"horror"'},
                                 {'key': 'media', 'value': u'"dvd"'}],
                      'packages':[{'name': 'annakarenina2'}, {'id': pkg.id}]
                      }


        model.repo.new_revision()
        group_dict_save(group_dict, context)
        model.Session.commit()
        model.Session.remove()

        group = model.Session.query(model.Group).filter_by(name=u'help').one()

        group_dictized = group_dictize(group, context)

        expected =  {'description': u'',
                    'extras': [{'key': u'genre', 'state': u'active', 'value': u'"horror"'},
                               {'key': u'media', 'state': u'active', 'value': u'"dvd"'}],
                    'name': u'help',
                    'packages': [{'author': None,
                                  'author_email': None,
                                  'license_id': u'other-open',
                                  'maintainer': None,
                                  'maintainer_email': None,
                                  'name': u'annakarenina3',
                                  'notes': u'Some test notes\n\n### A 3rd level heading\n\n**Some bolded text.**\n\n*Some italicized text.*\n\nForeign characters:\nu with umlaut \xfc\n66-style quote \u201c\nforeign word: th\xfcmb\n \nNeeds escaping:\nleft arrow <\n\n<http://ckan.net/>\n\n',
                                  'state': u'active',
                                  'title': u'A Novel By Tolstoy',
                                  'url': u'http://www.annakarenina.com',
                                  'version': u'0.7a'},
                                 {'author': None,
                                  'author_email': None,
                                  'license_id': u'other-open',
                                  'maintainer': None,
                                  'maintainer_email': None,
                                  'name': u'annakarenina2',
                                  'notes': u'Some test notes\n\n### A 3rd level heading\n\n**Some bolded text.**\n\n*Some italicized text.*\n\nForeign characters:\nu with umlaut \xfc\n66-style quote \u201c\nforeign word: th\xfcmb\n \nNeeds escaping:\nleft arrow <\n\n<http://ckan.net/>\n\n',
                                  'state': u'active',
                                  'title': u'A Novel By Tolstoy',
                                  'url': u'http://www.annakarenina.com',
                                  'version': u'0.7a'}],
                    'state': u'active',
                    'title': u'help'}

        expected['packages'] = sorted(expected['packages'], key=lambda x: x['name'])

        result = self.remove_changable_columns(group_dictized)

        result['packages'] = sorted(result['packages'], key=lambda x: x['name'])

        assert result == expected, pformat(result)
Example #7
0
def group_create(context, data_dict):
    model = context['model']
    user = context['user']
    schema = context.get('schema') or default_group_schema()

    check_access(model.System(), model.Action.GROUP_CREATE, context)

    data, errors = validate(data_dict, schema, context)

    if errors:
        model.Session.rollback()
        raise ValidationError(errors, group_error_summary(errors))

    rev = model.repo.new_revision()
    rev.author = user

    if 'message' in context:
        rev.message = context['message']
    else:
        rev.message = _(u'REST API: Create object %s') % data.get("name")

    group = group_dict_save(data, context)

    if user:
        admins = [model.User.by_name(user.decode('utf8'))]
    else:
        admins = []
    model.setup_default_user_roles(group, admins)
    for item in PluginImplementations(IGroupController):
        item.create(group)
    model.repo.commit()
    context["group"] = group
    context["id"] = group.id
    log.debug('Created object %s' % str(group.name))
    return group_dictize(group, context)
Example #8
0
def dge_organization_publisher(context, data_dict=None):
    try:
        model = context['model']
        id = logic.get_or_bust(data_dict, 'id')
        group = model.Group.get(id)
        context['group'] = group
        if group is None:
            raise NotFound
        if not group.is_organization:
            raise NotFound
        group_dict = model_dictize.group_dictize(
            group,
            context,
            packages_field='dataset_count',
            include_tags=False,
            include_extras=True,
            include_groups=False,
            include_users=False,
        )
        group_plugin = lib_plugins.lookup_group_plugin(group_dict['type'])
        schema = logic.schema.default_show_group_schema()
        group_dict, errors = lib_plugins.plugin_validate(
            group_plugin, context, group_dict, schema, 'organization_show')
        return group_dict
    except:
        return {}
Example #9
0
def group_create(context, data_dict):
    model = context['model']
    user = context['user']
    schema = context.get('schema') or default_group_schema()

    check_access(model.System(), model.Action.GROUP_CREATE, context)

    data, errors = validate(data_dict, schema, context)

    if errors:
        model.Session.rollback()
        raise ValidationError(errors, group_error_summary(errors))

    rev = model.repo.new_revision()
    rev.author = user

    if 'message' in context:
        rev.message = context['message']
    else:
        rev.message = _(u'REST API: Create object %s') % data.get("name")

    group = group_dict_save(data, context)

    if user:
        admins = [model.User.by_name(user.decode('utf8'))]
    else:
        admins = []
    model.setup_default_user_roles(group, admins)
    for item in PluginImplementations(IGroupController):
        item.create(group)
    model.repo.commit()        
    context["group"] = group
    context["id"] = group.id
    log.debug('Created object %s' % str(group.name))
    return group_dictize(group, context)
Example #10
0
def group_show(context, data_dict):
    '''Shows group details'''
    model = context['model']
    id = data_dict['id']

    group = model.Group.get(id)
    context['group'] = group

    if group is None:
        raise NotFound

    check_access('group_show', context, data_dict)

    group_dict = model_dictize.group_dictize(group, context)

    for item in plugins.PluginImplementations(plugins.IGroupController):
        item.read(group)

    schema = lib_plugins.lookup_group_plugin(
        group_dict['type']).db_to_form_schema()

    if schema:
        package_dict, errors = validate(group_dict, schema, context=context)

    return group_dict
    def test_2_group_schema(self):

        context = {"model": model, "session": model.Session}

        group = model.Session.query(model.Group).first()

        data = group_dictize(group, context)

        converted_data, errors = validate(data, default_group_schema(), context)
        group_pack = sorted(group.packages, key=lambda x: x.id)

        converted_data["packages"] = sorted(converted_data["packages"], key=lambda x: x["id"])

        expected = {
            "description": u"These are books that David likes.",
            "id": group.id,
            "name": u"david",
            "packages": sorted([{"id": group_pack[0].id}, {"id": group_pack[1].id}], key=lambda x: x["id"]),
            "title": u"Dave's books",
        }

        assert not errors
        assert converted_data == expected, pformat(converted_data) + "\n\n" + pformat(expected)

        data["packages"].sort(key=lambda x: x["id"])
        data["packages"][0]["id"] = "fjdlksajfalsf"
        data["packages"][1].pop("id")
        data["packages"][1].pop("name")

        converted_data, errors = validate(data, default_group_schema(), context)
        assert errors == {"packages": [{"id": [u"Dataset was not found."]}, {"id": [u"Missing value"]}]}, pformat(
            errors
        )
Example #12
0
    def test_group_dictize_group_with_extra(self):
        factories.Group(extras=[{"key": "k1", "value": "v1"}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert group["extras"][0]["key"] == "k1"
Example #13
0
    def test_group_dictize_group_with_extra(self):
        factories.Group(extras=[{'key': 'k1', 'value': 'v1'}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(group['extras'][0]['key'], 'k1')
Example #14
0
    def test_group_dictize_group_with_extra(self):
        factories.Group(extras=[{'key': 'k1', 'value': 'v1'}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(group['extras'][0]['key'], 'k1')
Example #15
0
    def test_group_dictize_group_with_dataset(self):
        group_obj = factories.Group.model()
        package = factories.Dataset(groups=[{"name": group_obj.name}])
        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert group["packages"][0]["name"] == package["name"]
        assert group["packages"][0]["groups"][0]["name"] == group_obj.name
Example #16
0
    def test_group_dictize_group_with_parent_group(self):
        parent = factories.Group(title="Parent")
        group_obj = factories.Group.model(title="Child", groups=[{"name": parent["name"]}])
        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert len(group["groups"]) == 1
        assert group["groups"][0]["name"] == parent["name"]
        assert group["groups"][0]["package_count"] == 0
Example #17
0
    def test_group_dictize_for_org_with_package_list(self):
        group_obj = factories.Organization.model()
        package = factories.Dataset(owner_org=group_obj.id)
        context = {"model": model, "session": model.Session}

        org = model_dictize.group_dictize(group_obj, context)

        assert type(org["packages"]) == list
        assert len(org["packages"]) == 1
        assert org["packages"][0]["name"] == package["name"]
Example #18
0
    def test_group_dictize_with_package_list_limited_by_config(self):
        group_obj = factories.Group.model()
        for _ in range(5):
            factories.Dataset(groups=[{"name": group_obj.name}])

        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert len(group["packages"]) == 4
Example #19
0
    def test_group_dictize_with_package_list_limited_by_config(self):
        group_ = factories.Group()
        for _ in range(5):
            factories.Dataset(groups=[{'name': group_['name']}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(len(group['packages']), 4)
Example #20
0
    def test_group_dictize_with_package_list_limited_by_config(self):
        group_ = factories.Group()
        for _ in range(5):
            factories.Dataset(groups=[{'name': group_['name']}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(len(group['packages']), 4)
Example #21
0
    def test_group_dictize_with_package_list(self):
        group_obj = factories.Group.model()
        package = factories.Dataset(groups=[{"name": group_obj.name}])
        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert isinstance(group["packages"], list)
        assert len(group["packages"]) == 1
        assert group["packages"][0]["name"] == package["name"]
Example #22
0
    def test_group_dictize_group_with_dataset(self):
        group_ = factories.Group()
        package = factories.Dataset(groups=[{'name': group_['name']}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(group['packages'][0]['name'], package['name'])
        assert_equal(group['packages'][0]['groups'][0]['name'], group_['name'])
Example #23
0
    def test_group_dictize_with_package_list_limited_by_config(self):
        group_ = factories.Group()
        for _ in range(5):
            factories.Dataset(groups=[{"name": group_["name"]}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert len(group["packages"]) == 4
Example #24
0
    def test_group_dictize_group_with_dataset(self):
        group_ = factories.Group()
        package = factories.Dataset(groups=[{'name': group_['name']}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(group['packages'][0]['name'], package['name'])
        assert_equal(group['packages'][0]['groups'][0]['name'], group_['name'])
Example #25
0
    def test_group_dictize_group_with_dataset(self):
        group_ = factories.Group()
        package = factories.Dataset(groups=[{"name": group_["name"]}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert group["packages"][0]["name"] == package["name"]
        assert group["packages"][0]["groups"][0]["name"] == group_["name"]
Example #26
0
    def test_group_dictize_for_org_with_package_list(self):
        org_ = factories.Organization()
        package = factories.Dataset(owner_org=org_["id"])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {"model": model, "session": model.Session}

        org = model_dictize.group_dictize(group_obj, context)

        assert type(org["packages"]) == list
        assert len(org["packages"]) == 1
        assert org["packages"][0]["name"] == package["name"]
Example #27
0
    def test_group_dictize_group_with_parent_group(self):
        factories.Group(name="parent")
        factories.Group(name="child", groups=[{"name": "parent"}])
        group_obj = model.Group.get("child")
        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert len(group["groups"]) == 1
        assert group["groups"][0]["name"] == "parent"
        assert group["groups"][0]["package_count"] == 0
Example #28
0
    def test_group_dictize(self):
        group_obj = factories.Group.model()
        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert group["name"] == group_obj.name
        assert group["packages"] == []
        assert group["extras"] == []
        assert group["tags"] == []
        assert group["groups"] == []
 def group_display_name(group_id):
     if not group_id:
         return
     group = model.Group.get(group_id)
     group_dict = ckan_model_dictize.group_dictize(group,
                                                   context,
                                                   include_groups=False,
                                                   include_tags=False,
                                                   include_users=False,
                                                   include_extras=False)
     return group_dict['display_name']
Example #30
0
    def test_group_dictize_for_org_with_package_list(self):
        org_ = factories.Organization()
        package = factories.Dataset(owner_org=org_['id'])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        org = model_dictize.group_dictize(group_obj, context)

        assert_equal(type(org['packages']), list)
        assert_equal(len(org['packages']), 1)
        assert_equal(org['packages'][0]['name'], package['name'])
Example #31
0
    def test_group_dictize_group_with_parent_group(self):
        factories.Group(name='parent')
        factories.Group(name='child', groups=[{'name': 'parent'}])
        group_obj = model.Group.get('child')
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(len(group['groups']), 1)
        assert_equal(group['groups'][0]['name'], 'parent')
        assert_equal(group['groups'][0]['package_count'], 0)
Example #32
0
    def test_group_dictize_group_with_parent_group(self):
        factories.Group(name='parent')
        factories.Group(name='child', groups=[{'name': 'parent'}])
        group_obj = model.Group.get('child')
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(len(group['groups']), 1)
        assert_equal(group['groups'][0]['name'], 'parent')
        assert_equal(group['groups'][0]['package_count'], 0)
Example #33
0
    def test_group_dictize_for_org_with_package_list(self):
        org_ = factories.Organization()
        package = factories.Dataset(owner_org=org_['id'])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        org = model_dictize.group_dictize(group_obj, context)

        assert_equal(type(org['packages']), list)
        assert_equal(len(org['packages']), 1)
        assert_equal(org['packages'][0]['name'], package['name'])
Example #34
0
    def test_group_dictize_without_packages(self):
        # group_list_dictize might not be interested in packages at all
        # so sets these options. e.g. it is not all_fields nor are the results
        # sorted by the number of packages.
        group_obj = factories.Group.model()
        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(
            group_obj, context, packages_field=None
        )

        assert "packages" not in group
Example #35
0
    def test_group_dictize_without_packages(self):
        # group_list_dictize might not be interested in packages at all
        # so sets these options. e.g. it is not all_fields nor are the results
        # sorted by the number of packages.
        factories.Group()
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context,
                                            packages_field=None)

        assert 'packages' not in group
Example #36
0
    def test_group_dictize(self):
        group = factories.Group(name="test_dictize")
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {"model": model, "session": model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert group["name"] == "test_dictize"
        assert group["packages"] == []
        assert group["extras"] == []
        assert group["tags"] == []
        assert group["groups"] == []
Example #37
0
    def test_group_dictize(self):
        group = factories.Group(name='test_dictize')
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(group['name'], 'test_dictize')
        assert_equal(group['packages'], [])
        assert_equal(group['extras'], [])
        assert_equal(group['tags'], [])
        assert_equal(group['groups'], [])
Example #38
0
    def test_group_dictize(self):
        group = factories.Group()
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(group['name'], 'test_group_0')
        assert_equal(group['packages'], [])
        assert_equal(group['extras'], [])
        assert_equal(group['tags'], [])
        assert_equal(group['groups'], [])
Example #39
0
    def create(self, model_obj):
        otype = model_obj.type
        lang = helpers.getLanguage()

        ## CREATE GROUP OR ORGANIZATION
        if otype == 'group' or otype == 'organization' and lang:
            log.info('::::: Persisting localised metadata locale :::::')
            lang = helpers.getLanguage()

            group = model_dictize.group_dictize(model_obj, {'model': model, 'session': model.Session})

            GroupMultilang.persist(group, lang)
    def test_group_dictize_with_package_count(self):
        # group_list_dictize calls it like this by default
        group_ = factories.Group()
        factories.Dataset(groups=[{'name': group_['name']}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session,
                   'dataset_counts': model_dictize.get_group_dataset_counts()
                   }

        group = model_dictize.group_dictize(group_obj, context,
                                            packages_field='dataset_count')
        assert_equal(group['package_count'], 1)
    def test_group_dictize_without_packages(self):
        # group_list_dictize might not be interested in packages at all
        # so sets these options. e.g. it is not all_fields nor are the results
        # sorted by the number of packages.
        factories.Group()
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}

        group = model_dictize.group_dictize(group_obj, context,
                                            packages_field=None)

        assert 'packages' not in group
    def test_2_group_schema(self):
        group = model.Session.query(model.Group).first()
        data = group_dictize(group, self.context)

        # we don't want these here
        del data['groups']
        del data['users']
        del data['tags']
        del data['extras']

        converted_data, errors = validate(data,
                                          default_group_schema(),
                                          self.context)
        group_pack = sorted(group.packages(), key=lambda x: x.id)

        converted_data["packages"] = sorted(converted_data["packages"],
                                            key=lambda x: x["id"])

        expected = {
            'description': u'These are books that David likes.',
            'id': group.id,
            'name': u'david',
            'is_organization': False,
            'type': u'group',
            'image_url': u'',
            'image_display_url': u'',
            'packages': sorted([{'id': group_pack[0].id,
                                 'name': group_pack[0].name,
                                 'title': group_pack[0].title},
                                {'id': group_pack[1].id,
                                 'name': group_pack[1].name,
                                 'title':group_pack[1].title}],
                               key=lambda x: x["id"]),
            'title': u"Dave's books",
            'approval_status': u'approved'
        }

        assert not errors
        assert converted_data == expected, pformat(converted_data)

        data["packages"].sort(key=lambda x: x["id"])
        data["packages"][0]["id"] = 'fjdlksajfalsf'
        data["packages"][1].pop("id")
        data["packages"][1].pop("name")

        converted_data, errors = validate(data,
                                          default_group_schema(),
                                          self.context)
        assert errors == {
            'packages': [{'id': [u'Not found: Dataset']},
                         {'id': [u'Missing value']}]
        }, pformat(errors)
    def test_2_group_schema(self):
        group = model.Session.query(model.Group).first()
        data = group_dictize(group, self.context)

        # we don't want these here
        del data['groups']
        del data['users']
        del data['tags']
        del data['extras']

        converted_data, errors = validate(data,
                                          default_group_schema(),
                                          self.context)
        group_pack = sorted(group.packages(), key=lambda x: x.id)

        converted_data["packages"] = sorted(converted_data["packages"],
                                            key=lambda x: x["id"])

        expected = {
            'description': u'These are books that David likes.',
            'id': group.id,
            'name': u'david',
            'is_organization': False,
            'type': u'group',
            'image_url': u'',
            'image_display_url': u'',
            'packages': sorted([{'id': group_pack[0].id,
                                 'name': group_pack[0].name,
                                 'title': group_pack[0].title},
                                {'id': group_pack[1].id,
                                 'name': group_pack[1].name,
                                 'title':group_pack[1].title}],
                               key=lambda x: x["id"]),
            'title': u"Dave's books",
            'approval_status': u'approved'
        }

        assert not errors
        assert converted_data == expected, pformat(converted_data)

        data["packages"].sort(key=lambda x: x["id"])
        data["packages"][0]["id"] = 'fjdlksajfalsf'
        data["packages"][1].pop("id")
        data["packages"][1].pop("name")

        converted_data, errors = validate(data,
                                          default_group_schema(),
                                          self.context)
        assert errors == {
            'packages': [{'id': [u'Not found: Dataset']},
                         {'id': [u'Missing value']}]
        }, pformat(errors)
Example #44
0
    def test_group_dictize_with_no_packages_field_but_still_package_count(self):
        # logic.get.group_show calls it like this when not include_datasets
        group_ = factories.Group()
        factories.Dataset(groups=[{'name': group_['name']}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session}
        # not supplying dataset_counts in this case either

        group = model_dictize.group_dictize(group_obj, context,
                                            packages_field='dataset_count')

        assert 'packages' not in group
        assert_equal(group['package_count'], 1)
Example #45
0
    def test_group_dictize_for_org_with_package_count(self):
        # group_list_dictize calls it like this by default
        org_ = factories.Organization()
        factories.Dataset(owner_org=org_['id'])
        org_obj = model.Session.query(model.Group).filter_by().first()
        context = {'model': model, 'session': model.Session,
                   'dataset_counts': model_dictize.get_group_dataset_counts()
                   }

        org = model_dictize.group_dictize(org_obj, context,
                                          packages_field='dataset_count')

        assert_equal(org['packages'], 1)
Example #46
0
    def test_group_dictize_with_package_list_limited(self):
        '''
        Packages returned in group are limited by context var.
        '''
        group_ = factories.Group()
        for _ in range(10):
            factories.Dataset(groups=[{'name': group_['name']}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        # limit packages to 4
        context = {'model': model, 'session': model.Session, 'limits': {'packages': 4}}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(len(group['packages']), 4)
Example #47
0
    def test_group_dictize_with_package_list_limited_over(self):
        '''
        Packages limit is set higher than number of packages in group.
        '''
        group_ = factories.Group()
        for _ in range(3):
            factories.Dataset(groups=[{'name': group_['name']}])
        group_obj = model.Session.query(model.Group).filter_by().first()
        # limit packages to 4
        context = {'model': model, 'session': model.Session, 'limits': {'packages': 4}}

        group = model_dictize.group_dictize(group_obj, context)

        assert_equal(len(group['packages']), 3)
Example #48
0
def organization_by_inventory_id(context, data_dict):
    model = context['model']
    id = get_or_bust(data_dict, 'id')

    group_extra = model.meta.Session.query(model.GroupExtra) \
                       .filter_by(key='inventory_organization_id') \
                       .filter_by(value=id).first()
    if group_extra is None:
        raise ObjectNotFound('No GroupExtra with specificied inventory id')

    organization = model.meta.Session.query(model.Group) \
                        .filter_by(id=group_extra.group_id).first()
    if organization is None:
        raise ObjectNotFound('No organization with specificied inventory id')

    return model_dictize.group_dictize(organization, context)
Example #49
0
def group_show(context, data_dict):
    model = context['model']
    id = data_dict['id']
    api = context.get('api_version') or '1'


    group = model.Group.get(id)
    context['group'] = group

    if group is None:
        raise NotFound
    check_access(group, model.Action.READ, context)

    group_dict = group_dictize(group, context)

    for item in PluginImplementations(IGroupController):
        item.read(group)

    return group_dict
Example #50
0
    def test_2_group_schema(self):
        group = model.Session.query(model.Group).first()
        data = group_dictize(group, self.context)

        # we don't want these here
        del data["groups"]
        del data["users"]
        del data["tags"]
        del data["extras"]

        converted_data, errors = validate(data, default_group_schema(), self.context)
        group_pack = sorted(group.packages(), key=lambda x: x.id)

        converted_data["packages"] = sorted(converted_data["packages"], key=lambda x: x["id"])

        expected = {
            "description": u"These are books that David likes.",
            "id": group.id,
            "name": u"david",
            "is_organization": False,
            "type": u"group",
            "image_url": u"",
            "packages": sorted(
                [
                    {"id": group_pack[0].id, "name": group_pack[0].name, "title": group_pack[0].title},
                    {"id": group_pack[1].id, "name": group_pack[1].name, "title": group_pack[1].title},
                ],
                key=lambda x: x["id"],
            ),
            "title": u"Dave's books",
            "approval_status": u"approved",
        }

        assert not errors
        assert converted_data == expected, pformat(converted_data)

        data["packages"].sort(key=lambda x: x["id"])
        data["packages"][0]["id"] = "fjdlksajfalsf"
        data["packages"][1].pop("id")
        data["packages"][1].pop("name")

        converted_data, errors = validate(data, default_group_schema(), self.context)
        assert errors == {"packages": [{"id": [u"Not found: Dataset"]}, {"id": [u"Missing value"]}]}, pformat(errors)
Example #51
0
File: get.py Project: icmurray/ckan
def group_show(context, data_dict):
    '''Shows group details'''
    model = context['model']
    id = data_dict['id']
    api = context.get('api_version') or '1'


    group = model.Group.get(id)
    context['group'] = group

    if group is None:
        raise NotFound

    check_access('group_show',context, data_dict)

    group_dict = model_dictize.group_dictize(group, context)

    for item in plugins.PluginImplementations(plugins.IGroupController):
        item.read(group)

    return group_dict
Example #52
0
File: get.py Project: jasonzou/ckan
def group_show(context, data_dict):
    """Shows group details"""

    model = context["model"]
    id = data_dict["id"]
    api = context.get("api_version") or "1"

    group = model.Group.get(id)
    context["group"] = group

    if group is None:
        raise NotFound

    check_access("group_show", context, data_dict)

    group_dict = group_dictize(group, context)

    for item in PluginImplementations(IGroupController):
        item.read(group)

    return group_dict
Example #53
0
def group_update(context, data_dict):

    model = context['model']
    user = context['user']
    schema = context.get('schema') or default_update_group_schema()
    id = data_dict['id']

    group = model.Group.get(id)
    context["group"] = group
    if group is None:
        raise NotFound('Group was not found.')

    check_access('group_update', context, data_dict)

    data, errors = validate(data_dict, schema, context)
    if errors:
        model.Session.rollback()
        raise ValidationError(errors, group_error_summary(errors))

    rev = model.repo.new_revision()
    rev.author = user
    
    if 'message' in context:
        rev.message = context['message']
    else:
        rev.message = _(u'REST API: Update object %s') % data.get("name")

    group = group_dict_save(data, context)

    for item in PluginImplementations(IGroupController):
        item.edit(group)

    if not context.get('defer_commit'):
        model.repo.commit()        
    if errors:
        raise ValidationError(errors)

    return group_dictize(group, context)
Example #54
0
def group_update(context, data_dict):

    model = context["model"]
    user = context["user"]
    schema = context.get("schema") or default_update_group_schema()
    id = data_dict["id"]

    group = model.Group.get(id)
    context["group"] = group
    if group is None:
        raise NotFound("Group was not found.")

    check_access("group_update", context, data_dict)

    data, errors = validate(data_dict, schema, context)
    if errors:
        model.Session.rollback()
        raise ValidationError(errors, group_error_summary(errors))

    rev = model.repo.new_revision()
    rev.author = user

    if "message" in context:
        rev.message = context["message"]
    else:
        rev.message = _(u"REST API: Update object %s") % data.get("name")

    group = group_dict_save(data, context)

    for item in PluginImplementations(IGroupController):
        item.edit(group)

    model.repo.commit()
    if errors:
        raise ValidationError(errors)

    return group_dictize(group, context)
Example #55
0
def group_show(context, data_dict):
    '''Shows group details'''
    model = context['model']
    id = data_dict['id']

    group = model.Group.get(id)
    context['group'] = group

    if group is None:
        raise NotFound

    check_access('group_show',context, data_dict)

    group_dict = model_dictize.group_dictize(group, context)

    for item in plugins.PluginImplementations(plugins.IGroupController):
        item.read(group)

    schema = lib_plugins.lookup_group_plugin(group_dict['type']).db_to_form_schema()

    if schema:
        package_dict, errors = validate(group_dict, schema, context=context)

    return group_dict
Example #56
0
def group_update(context, data_dict):
    model = context['model']
    user = context['user']
    session = context['session']
    id = data_dict['id']
    parent = context.get('parent', None)

    group = model.Group.get(id)
    context["group"] = group
    if group is None:
        raise NotFound('Group was not found.')

    # get the schema
    group_plugin = lib_plugins.lookup_group_plugin(group.type)
    try:
        schema = group_plugin.form_to_db_schema_options({'type':'update',
                                               'api':'api_version' in context,
                                               'context': context})
    except AttributeError:
        schema = group_plugin.form_to_db_schema()

    check_access('group_update', context, data_dict)

    data, errors = validate(data_dict, schema, context)
    if errors:
        session.rollback()
        raise ValidationError(errors, error_summary(errors))

    rev = model.repo.new_revision()
    rev.author = user

    if 'message' in context:
        rev.message = context['message']
    else:
        rev.message = _(u'REST API: Update object %s') % data.get("name")

    group = model_save.group_dict_save(data, context)

    if parent:
        parent_group = model.Group.get( parent )
        if parent_group and not parent_group in group.get_groups(group.type):
            # Delete all of this groups memberships
            current = session.query(model.Member).\
               filter(model.Member.table_id == group.id).\
               filter(model.Member.table_name == "group").all()
            for c in current:
                session.delete(c)
            member = model.Member(group=parent_group, table_id=group.id, table_name='group')
            session.add(member)


    for item in plugins.PluginImplementations(plugins.IGroupController):
        item.edit(group)

    activity_dict = {
            'user_id': model.User.by_name(user.decode('utf8')).id,
            'object_id': group.id,
            'activity_type': 'changed group',
            }
    # Handle 'deleted' groups.
    # When the user marks a group as deleted this comes through here as
    # a 'changed' group activity. We detect this and change it to a 'deleted'
    # activity.
    if group.state == u'deleted':
        if session.query(ckan.model.Activity).filter_by(
                object_id=group.id, activity_type='deleted').all():
            # A 'deleted group' activity for this group has already been
            # emitted.
            # FIXME: What if the group was deleted and then activated again?
            activity_dict = None
        else:
            # We will emit a 'deleted group' activity.
            activity_dict['activity_type'] = 'deleted group'
    if activity_dict is not None:
        activity_dict['data'] = {
                'group': ckan.lib.dictization.table_dictize(group, context)
                }
        activity_create_context = {
            'model': model,
            'user': user,
            'defer_commit':True,
            'session': session
        }
        get_action('activity_create')(activity_create_context, activity_dict,
                ignore_auth=True)
        # TODO: Also create an activity detail recording what exactly changed
        # in the group.

    if not context.get('defer_commit'):
        model.repo.commit()

    return model_dictize.group_dictize(group, context)
Example #57
0
def _group_or_org_update(context, data_dict, is_org=False):
    model = context["model"]
    user = context["user"]
    session = context["session"]
    id = _get_or_bust(data_dict, "id")
    parent = context.get("parent", None)

    group = model.Group.get(id)
    context["group"] = group
    if group is None:
        raise NotFound("Group was not found.")

    # get the schema
    group_plugin = lib_plugins.lookup_group_plugin(group.type)
    try:
        schema = group_plugin.form_to_db_schema_options(
            {"type": "update", "api": "api_version" in context, "context": context}
        )
    except AttributeError:
        schema = group_plugin.form_to_db_schema()

    if is_org:
        _check_access("organization_update", context, data_dict)
    else:
        _check_access("group_update", context, data_dict)

    if "api_version" not in context:
        # old plugins do not support passing the schema so we need
        # to ensure they still work
        try:
            group_plugin.check_data_dict(data_dict, schema)
        except TypeError:
            group_plugin.check_data_dict(data_dict)

    data, errors = _validate(data_dict, schema, context)
    log.debug(
        "group_update validate_errs=%r user=%s group=%s data_dict=%r",
        errors,
        context.get("user"),
        context.get("group").name if context.get("group") else "",
        data_dict,
    )

    if errors:
        session.rollback()
        raise ValidationError(errors)

    rev = model.repo.new_revision()
    rev.author = user

    if "message" in context:
        rev.message = context["message"]
    else:
        rev.message = _(u"REST API: Update object %s") % data.get("name")

    # when editing an org we do not want to update the packages if using the
    # new templates.
    if (
        (not is_org)
        and not paste.deploy.converters.asbool(config.get("ckan.legacy_templates", False))
        and "api_version" not in context
    ):
        context["prevent_packages_update"] = True
    group = model_save.group_dict_save(data, context)

    if parent:
        parent_group = model.Group.get(parent)
        if parent_group and not parent_group in group.get_groups(group.type):
            # Delete all of this groups memberships
            current = (
                session.query(model.Member)
                .filter(model.Member.table_id == group.id)
                .filter(model.Member.table_name == "group")
                .all()
            )
            if current:
                log.debug(
                    "Parents of group %s deleted: %r", group.name, [membership.group.name for membership in current]
                )
            for c in current:
                session.delete(c)
            member = model.Member(group=parent_group, table_id=group.id, table_name="group")
            session.add(member)
            log.debug("Group %s is made child of group %s", group.name, parent_group.name)

    if is_org:
        plugin_type = plugins.IOrganizationController
    else:
        plugin_type = plugins.IGroupController

    for item in plugins.PluginImplementations(plugin_type):
        item.edit(group)

    if is_org:
        activity_type = "changed organization"
    else:
        activity_type = "changed group"

    activity_dict = {
        "user_id": model.User.by_name(user.decode("utf8")).id,
        "object_id": group.id,
        "activity_type": activity_type,
    }
    # Handle 'deleted' groups.
    # When the user marks a group as deleted this comes through here as
    # a 'changed' group activity. We detect this and change it to a 'deleted'
    # activity.
    if group.state == u"deleted":
        if session.query(ckan.model.Activity).filter_by(object_id=group.id, activity_type="deleted").all():
            # A 'deleted group' activity for this group has already been
            # emitted.
            # FIXME: What if the group was deleted and then activated again?
            activity_dict = None
        else:
            # We will emit a 'deleted group' activity.
            activity_dict["activity_type"] = "deleted group"
    if activity_dict is not None:
        activity_dict["data"] = {"group": ckan.lib.dictization.table_dictize(group, context)}
        activity_create_context = {"model": model, "user": user, "defer_commit": True, "session": session}
        _get_action("activity_create")(activity_create_context, activity_dict, ignore_auth=True)
        # TODO: Also create an activity detail recording what exactly changed
        # in the group.

    if not context.get("defer_commit"):
        model.repo.commit()

    return model_dictize.group_dictize(group, context)
Example #58
0
def _group_or_org_create(context, data_dict, is_org=False):
    model = context['model']
    user = context['user']
    session = context['session']
    parent = context.get('parent', None)
    data_dict['is_organization'] = is_org


    # get the schema
    group_plugin = lib_plugins.lookup_group_plugin(
            group_type=data_dict.get('type'))
    try:
        schema = group_plugin.form_to_db_schema_options({'type':'create',
                                               'api':'api_version' in context,
                                               'context': context})
    except AttributeError:
        schema = group_plugin.form_to_db_schema()

    if 'api_version' not in context:
        # old plugins do not support passing the schema so we need
        # to ensure they still work
        try:
            group_plugin.check_data_dict(data_dict, schema)
        except TypeError:
            group_plugin.check_data_dict(data_dict)

    data, errors = _validate(data_dict, schema, context)
    log.debug('group_create validate_errs=%r user=%s group=%s data_dict=%r',
              errors, context.get('user'), data_dict.get('name'), data_dict)

    if errors:
        session.rollback()
        raise ValidationError(errors)

    rev = model.repo.new_revision()
    rev.author = user

    if 'message' in context:
        rev.message = context['message']
    else:
        rev.message = _(u'REST API: Create object %s') % data.get("name")

    group = model_save.group_dict_save(data, context)

    if parent:
        parent_group = model.Group.get( parent )
        if parent_group:
            member = model.Member(group=parent_group, table_id=group.id, table_name='group')
            session.add(member)
            log.debug('Group %s is made child of group %s',
                      group.name, parent_group.name)

    if user:
        admins = [model.User.by_name(user.decode('utf8'))]
    else:
        admins = []
    model.setup_default_user_roles(group, admins)
    # Needed to let extensions know the group id
    session.flush()

    if is_org:
        plugin_type = plugins.IOrganizationController
    else:
        plugin_type = plugins.IGroupController

    for item in plugins.PluginImplementations(plugin_type):
        item.create(group)

    if is_org:
        activity_type = 'new organization'
    else:
        activity_type = 'new group'

    user_id = model.User.by_name(user.decode('utf8')).id

    activity_dict = {
            'user_id': user_id,
            'object_id': group.id,
            'activity_type': activity_type,
            }
    activity_dict['data'] = {
            'group': ckan.lib.dictization.table_dictize(group, context)
            }
    activity_create_context = {
        'model': model,
        'user': user,
        'defer_commit':True,
        'session': session
    }
    logic.get_action('activity_create')(activity_create_context,
            activity_dict, ignore_auth=True)

    if not context.get('defer_commit'):
        model.repo.commit()
    context["group"] = group
    context["id"] = group.id

    # creator of group/org becomes an admin
    # this needs to be after the repo.commit or else revisions break
    member_dict = {
        'id': group.id,
        'object': user_id,
        'object_type': 'user',
        'capacity': 'admin',
    }
    member_create_context = {
        'model': model,
        'user': user,
        'ignore_auth': True, # we are not a member of the group at this point
        'session': session
    }
    logic.get_action('member_create')(member_create_context, member_dict)

    log.debug('Created object %s' % str(group.name))
    return model_dictize.group_dictize(group, context)
Example #59
0
def _group_or_org_update(context, data_dict, is_org=False):
    model = context['model']
    user = context['user']
    session = context['session']
    id = _get_or_bust(data_dict, 'id')

    group = model.Group.get(id)
    context["group"] = group
    if group is None:
        raise NotFound('Group was not found.')

    # get the schema
    group_plugin = lib_plugins.lookup_group_plugin(group.type)
    try:
        schema = group_plugin.form_to_db_schema_options({'type':'update',
                                               'api':'api_version' in context,
                                               'context': context})
    except AttributeError:
        schema = group_plugin.form_to_db_schema()

    upload = uploader.Upload('group', group.image_url)
    upload.update_data_dict(data_dict, 'image_url',
                           'image_upload', 'clear_upload')

    if is_org:
        _check_access('organization_update', context, data_dict)
    else:
        _check_access('group_update', context, data_dict)

    if 'api_version' not in context:
        # old plugins do not support passing the schema so we need
        # to ensure they still work
        try:
            group_plugin.check_data_dict(data_dict, schema)
        except TypeError:
            group_plugin.check_data_dict(data_dict)

    data, errors = lib_plugins.plugin_validate(
        group_plugin, context, data_dict, schema,
        'organization_update' if is_org else 'group_update')
    log.debug('group_update validate_errs=%r user=%s group=%s data_dict=%r',
              errors, context.get('user'),
              context.get('group').name if context.get('group') else '',
              data_dict)

    if errors:
        session.rollback()
        raise ValidationError(errors)

    rev = model.repo.new_revision()
    rev.author = user

    if 'message' in context:
        rev.message = context['message']
    else:
        rev.message = _(u'REST API: Update object %s') % data.get("name")

    # when editing an org we do not want to update the packages if using the
    # new templates.
    if ((not is_org)
            and not converters.asbool(
                config.get('ckan.legacy_templates', False))
            and 'api_version' not in context):
        context['prevent_packages_update'] = True
    group = model_save.group_dict_save(data, context)

    if is_org:
        plugin_type = plugins.IOrganizationController
    else:
        plugin_type = plugins.IGroupController

    for item in plugins.PluginImplementations(plugin_type):
        item.edit(group)

    if is_org:
        activity_type = 'changed organization'
    else:
        activity_type = 'changed group'

    activity_dict = {
            'user_id': model.User.by_name(user.decode('utf8')).id,
            'object_id': group.id,
            'activity_type': activity_type,
            }
    # Handle 'deleted' groups.
    # When the user marks a group as deleted this comes through here as
    # a 'changed' group activity. We detect this and change it to a 'deleted'
    # activity.
    if group.state == u'deleted':
        if session.query(ckan.model.Activity).filter_by(
                object_id=group.id, activity_type='deleted').all():
            # A 'deleted group' activity for this group has already been
            # emitted.
            # FIXME: What if the group was deleted and then activated again?
            activity_dict = None
        else:
            # We will emit a 'deleted group' activity.
            activity_dict['activity_type'] = 'deleted group'
    if activity_dict is not None:
        activity_dict['data'] = {
                'group': dictization.table_dictize(group, context)
                }
        activity_create_context = {
            'model': model,
            'user': user,
            'defer_commit': True,
            'ignore_auth': True,
            'session': session
        }
        # DGU checks if activity streams are enabled first, to avoid Auth Audit
        # issue #1421
        if converters.asbool(
                config.get('ckan.activity_streams_enabled', 'true')):
            _get_action('activity_create')(activity_create_context, activity_dict)
        # TODO: Also create an activity detail recording what exactly changed
        # in the group.

    upload.upload(uploader.get_max_image_size())
    if not context.get('defer_commit'):
        model.repo.commit()


    return model_dictize.group_dictize(group, context)