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
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
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
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)
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)
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 {}
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 )
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"
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')
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
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
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"]
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
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)
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"]
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'])
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
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"]
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"]
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
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']
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'])
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)
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
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_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"] == []
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'], [])
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'], [])
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_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_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)
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)
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)
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)
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)
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
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)
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
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
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)
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)
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 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)
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)
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)
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)