def setup_class(self):
model.Session.remove()
CreateTestData.create()
self.name = u'revisiontest1'
# create pkg
self.description = [
u'Written by Puccini', u'Written by Rossini',
u'Not written at all', u'Written again', u'Written off'
]
rev = model.repo.new_revision()
self.grp = model.Group(name=self.name)
self.grp.description = self.description[0]
model.Session.add(self.grp)
model.setup_default_user_roles(self.grp)
model.repo.commit_and_remove()
# edit pkg
for i in range(5)[1:]:
rev = model.repo.new_revision()
grp = model.Group.by_name(self.name)
grp.description = self.description[i]
model.repo.commit_and_remove()
self.grp = model.Group.by_name(self.name)
def test_10_edit_group(self):
# create a group with testgroupvalues
group = model.Group.by_name(self.testgroupvalues['name'])
if not group:
offset = self.offset('/rest/group')
postparams = '%s=1' % self.dumps(self.testgroupvalues)
res = self.app.post(offset, params=postparams, status=[201],
extra_environ=self.extra_environ)
model.Session.remove()
group = model.Group.by_name(self.testgroupvalues['name'])
assert group
assert len(group.member_all) == 2, group.member_all
user = model.User.by_name(self.user_name)
model.setup_default_user_roles(group, [user])
# edit it
group_vals = {'name':u'somethingnew', 'title':u'newtesttitle',
'packages':[u'annakarenina']}
offset = self.group_offset(self.testgroupvalues['name'])
postparams = '%s=1' % self.dumps(group_vals)
res = self.app.post(offset, params=postparams, status=[200],
extra_environ=self.extra_environ)
model.Session.remove()
group = model.Session.query(model.Group).filter_by(name=group_vals['name']).one()
package = model.Session.query(model.Package).filter_by(name='annakarenina').one()
assert group.name == group_vals['name']
assert group.title == group_vals['title']
assert len(group.member_all) == 2, group.member_all
assert len([mem for mem in group.member_all if mem.state == 'active']) == 1, group.member_all
for mem in group.member_all:
if mem.state == 'active':
assert mem.table_id == package.id
def setup_class(self):
CreateTestData.create()
model.repo.new_revision()
model.Session.add(model.Package(name=u'testpkgag'))
model.Session.add(model.Group(name=u'testgroupag'))
model.Session.add(model.User(name=u'ag_member'))
model.Session.add(model.User(name=u'ag_admin'))
model.Session.add(model.User(name=u'ag_notmember'))
model.Session.add(model.AuthorizationGroup(name=u'authz_group'))
model.repo.commit_and_remove()
pkg = model.Package.by_name(u'testpkgag')
grp = model.Group.by_name(u'testgroupag')
authzgrp = model.AuthorizationGroup.by_name(u'authz_group')
member = model.User.by_name(u'ag_member')
admin = model.User.by_name(u'ag_admin')
model.setup_default_user_roles(authzgrp, [admin])
model.add_authorization_group_to_role(authzgrp, model.Role.ADMIN, pkg)
model.add_authorization_group_to_role(authzgrp, model.Role.ADMIN, grp)
model.add_user_to_authorization_group(member, authzgrp, model.Role.EDITOR)
model.repo.commit_and_remove()
self.authorizer = ckan.authz.Authorizer()
self.pkg = model.Package.by_name(u'testpkgag')
self.grp = model.Group.by_name(u'testgroupag')
self.member = model.User.by_name(u'ag_member')
self.admin = model.User.by_name(u'ag_admin')
self.notmember = model.User.by_name(u'ag_notmember')
self.authzgrp = model.AuthorizationGroup.by_name(u'authz_group')
def test_10_edit_pkg_with_download_url(self):
test_params = {
'name': u'testpkg10',
'download_url': u'testurl',
}
rev = model.repo.new_revision()
pkg = model.Package()
model.Session.add(pkg)
pkg.name = test_params['name']
pkg.download_url = test_params['download_url']
model.Session.commit()
pkg = self.get_package_by_name(test_params['name'])
model.setup_default_user_roles(pkg, [self.user])
rev = model.repo.new_revision()
model.repo.commit_and_remove()
assert self.get_package_by_name(test_params['name'])
# edit it
pkg_vals = {'download_url': u'newurl'}
offset = self.package_offset(test_params['name'])
postparams = '%s=1' % self.dumps(pkg_vals)
res = self.app.post(offset,
params=postparams,
status=[200],
extra_environ=self.extra_environ)
model.Session.remove()
pkg = model.Session.query(
model.Package).filter_by(name=test_params['name']).one()
assert len(pkg.resources) == 1, pkg.resources
assert pkg.resources[0].url == pkg_vals['download_url']
def test_10_edit_group_name_duplicate(self):
# create a group with testgroupvalues
if not model.Group.by_name(self.testgroupvalues['name']):
rev = model.repo.new_revision()
group = model.Group()
model.Session.add(group)
group.name = self.testgroupvalues['name']
model.Session.commit()
group = model.Group.by_name(self.testgroupvalues['name'])
model.setup_default_user_roles(group, [self.user])
rev = model.repo.new_revision()
model.repo.commit_and_remove()
assert model.Group.by_name(self.testgroupvalues['name'])
# create a group with name 'dupname'
dupname = u'dupname'
if not model.Group.by_name(dupname):
rev = model.repo.new_revision()
group = model.Group()
model.Session.add(group)
group.name = dupname
model.Session.commit()
assert model.Group.by_name(dupname)
# edit first group to have dupname
group_vals = {'name':dupname}
offset = self.group_offset(self.testgroupvalues['name'])
postparams = '%s=1' % self.dumps(group_vals)
res = self.app.post(offset, params=postparams, status=[409],
extra_environ=self.extra_environ)
self.assert_json_response(res, 'Group name already exists')
def test_10_edit_group(self):
# create a group with testgroupvalues
group = model.Group.by_name(self.testgroupvalues['name'])
if not group:
offset = self.offset('/rest/group')
postparams = '%s=1' % self.dumps(self.testgroupvalues)
res = self.app.post(offset, params=postparams, status=[201],
extra_environ=self.extra_environ)
model.Session.remove()
group = model.Group.by_name(self.testgroupvalues['name'])
assert group
assert len(group.member_all) == 3, group.member_all
user = model.User.by_name(self.user_name)
model.setup_default_user_roles(group, [user])
# edit it
group_vals = {'name':u'somethingnew', 'title':u'newtesttitle',
'packages':[u'annakarenina']}
offset = self.group_offset(self.testgroupvalues['name'])
postparams = '%s=1' % self.dumps(group_vals)
res = self.app.post(offset, params=postparams, status=[200],
extra_environ=self.extra_environ)
model.Session.remove()
group = model.Session.query(model.Group).filter_by(name=group_vals['name']).one()
package = model.Session.query(model.Package).filter_by(name='annakarenina').one()
assert group.name == group_vals['name']
assert group.title == group_vals['title']
assert len(group.member_all) == 3, group.member_all
assert len([mem for mem in group.member_all if mem.state == 'active']) == 2, group.member_all
for mem in group.member_all:
if mem.state == 'active' and mem.capacity == 'package':
assert mem.table_id == package.id
def setup_class(cls):
model.Session.remove()
model.repo.init_db()
cls.name = u'revisiontest1'
# create pkg
cls.notes = [u'Written by Puccini', u'Written by Rossini', u'Not written at all', u'Written again', u'Written off']
rev = model.repo.new_revision()
cls.pkg1 = model.Package(name=cls.name)
cls.pkg1.notes = cls.notes[0]
model.Session.add(cls.pkg1)
model.setup_default_user_roles(cls.pkg1)
model.repo.commit_and_remove()
# edit pkg
for i in range(5)[1:]:
rev = model.repo.new_revision()
pkg1 = model.Package.by_name(cls.name)
pkg1.notes = cls.notes[i]
model.repo.commit_and_remove()
cls.pkg1 = model.Package.by_name(cls.name)
cls.revision_ids = [rev[0].id for rev in cls.pkg1.all_related_revisions]
# revision ids are newest first
cls.revision_timestamps = [rev[0].timestamp for rev in cls.pkg1.all_related_revisions]
cls.offset = url_for(controller='package', action='history', id=cls.pkg1.name)
def setup_class(cls):
model.Session.remove()
model.repo.init_db()
cls.name = u'revisiontest1'
# create pkg
cls.notes = [
u'Written by Puccini', u'Written by Rossini',
u'Not written at all', u'Written again', u'Written off'
]
rev = model.repo.new_revision()
cls.pkg1 = model.Package(name=cls.name)
cls.pkg1.notes = cls.notes[0]
model.Session.add(cls.pkg1)
model.setup_default_user_roles(cls.pkg1)
model.repo.commit_and_remove()
# edit pkg
for i in range(5)[1:]:
rev = model.repo.new_revision()
pkg1 = model.Package.by_name(cls.name)
pkg1.notes = cls.notes[i]
model.repo.commit_and_remove()
cls.pkg1 = model.Package.by_name(cls.name)
cls.revision_ids = [
rev[0].id for rev in cls.pkg1.all_related_revisions
]
# revision ids are newest first
cls.revision_timestamps = [
rev[0].timestamp for rev in cls.pkg1.all_related_revisions
]
cls.offset = url_for(controller='package',
action='history',
id=cls.pkg1.name)
def setup_class(self):
# for the authorization editing tests we set up test data so:
# three users, madeup-sysadmin , madeup-administrator, and madeup-another
# one authzgroup
# two packages test6 and test6a, m-a is admin on both
model.repo.init_db()
model.repo.new_revision()
self.sysadmin = 'madeup-sysadmin'
sysadmin_user = model.User(name=unicode(self.sysadmin))
self.admin = 'madeup-administrator'
admin_user = model.User(name=unicode(self.admin))
self.another = u'madeup-another'
another_user = model.User(name=unicode(self.another))
self.authzgroup = u'madeup-authzgroup'
authzgroup = model.AuthorizationGroup(name=unicode(self.authzgroup))
for obj in sysadmin_user, admin_user, another_user, authzgroup:
model.Session.add(obj)
model.add_user_to_role(sysadmin_user, model.Role.ADMIN, model.System())
model.repo.new_revision()
self.pkgname = u'test6'
self.pkgname2 = u'test6a'
pkg = model.Package(name=self.pkgname)
pkg2 = model.Package(name=self.pkgname2)
model.Session.add(pkg)
model.Session.add(pkg2)
admin_user = model.User.by_name(unicode(self.admin))
assert admin_user
model.setup_default_user_roles(pkg, admins=[admin_user])
model.setup_default_user_roles(pkg2, admins=[admin_user])
model.repo.commit_and_remove()
def create_groups(cls, group_dicts, admin_user_name):
'''A more featured interface for creating groups.
All group fields can be filled, packages added and they can
have an admin user.'''
import ckan.model as model
rev = model.repo.new_revision()
# same name as user we create below
rev.author = cls.author
admin_user = model.User.by_name(admin_user_name)
assert isinstance(group_dicts, (list, tuple))
for group_dict in group_dicts:
group = model.Group(name=unicode(group_dict['name']))
for key in ('title', 'description'):
if group_dict.has_key(key):
setattr(group, key, group_dict[key])
pkg_names = group_dict.get('packages', [])
assert isinstance(pkg_names, (list, tuple))
for pkg_name in pkg_names:
pkg = model.Package.by_name(unicode(pkg_name))
assert pkg, pkg_name
pkg.groups.append(group)
model.Session.add(group)
model.setup_default_user_roles(group, [admin_user])
cls.group_names.add(group_dict['name'])
model.repo.commit_and_remove()
def create_groups(cls, group_dicts, admin_user_name=None):
"""A more featured interface for creating groups.
All group fields can be filled, packages added and they can
have an admin user."""
import ckan.model as model
rev = model.repo.new_revision()
# same name as user we create below
rev.author = cls.author
if admin_user_name:
admin_users = [model.User.by_name(admin_user_name)]
else:
admin_users = []
assert isinstance(group_dicts, (list, tuple))
group_attributes = set(("name", "title", "description", "parent_id"))
for group_dict in group_dicts:
group = model.Group(name=unicode(group_dict["name"]))
for key in group_dict:
if key in group_attributes:
setattr(group, key, group_dict[key])
else:
group.extras[key] = group_dict[key]
pkg_names = group_dict.get("packages", [])
assert isinstance(pkg_names, (list, tuple))
for pkg_name in pkg_names:
pkg = model.Package.by_name(unicode(pkg_name))
assert pkg, pkg_name
pkg.groups.append(group)
model.Session.add(group)
model.setup_default_user_roles(group, admin_users)
cls.group_names.add(group_dict["name"])
model.repo.commit_and_remove()
def test_11_delete_group(self):
# Test Groups Entity Delete 200.
# create a group with testgroupvalues
group = model.Group.by_name(self.testgroupvalues['name'])
if not group:
rev = model.repo.new_revision()
group = model.Group()
model.Session.add(group)
group.name = self.testgroupvalues['name']
model.repo.commit_and_remove()
rev = model.repo.new_revision()
group = model.Group.by_name(self.testgroupvalues['name'])
model.setup_default_user_roles(group, [self.user])
model.repo.commit_and_remove()
assert group
user = model.User.by_name(self.user_name)
model.setup_default_user_roles(group, [user])
# delete it
offset = self.group_offset(self.testgroupvalues['name'])
res = self.app.delete(offset, status=[200],
extra_environ=self.extra_environ)
group = model.Group.by_name(self.testgroupvalues['name'])
assert group
assert group.state == 'deleted', group.state
res = self.app.get(offset, status=[403])
self.assert_json_response(res, 'Access denied')
res = self.app.get(offset, status=[200],
extra_environ=self.extra_environ)
def setup_class(self):
model.Session.remove()
CreateTestData.create()
self.name = u"revisiontest1"
# create pkg
self.description = [
u"Written by Puccini",
u"Written by Rossini",
u"Not written at all",
u"Written again",
u"Written off",
]
rev = model.repo.new_revision()
self.grp = model.Group(name=self.name)
self.grp.description = self.description[0]
model.Session.add(self.grp)
model.setup_default_user_roles(self.grp)
model.repo.commit_and_remove()
# edit pkg
for i in range(5)[1:]:
rev = model.repo.new_revision()
grp = model.Group.by_name(self.name)
grp.description = self.description[i]
model.repo.commit_and_remove()
self.grp = model.Group.by_name(self.name)
def _create_package(self, package=None):
rev = model.repo.new_revision()
rev.author = u'tester'
rev.message = u'Creating test data'
if not package:
package = model.Package()
relationship_attr = ['extras', 'resources', 'tags']
package_properties = {}
for key, value in self.new_pkg_dict.iteritems():
if key not in relationship_attr:
setattr(package, key, value)
tags = self.new_pkg_dict.get('tags', [])
for tag in tags:
package.add_tag_by_name(tag, autoflush=False)
for resource_dict in self.new_pkg_dict.get("resources", []):
resource = model.Resource(**resource_dict)
package.resources[:] = []
package.resources.append(resource)
for key, value in self.new_pkg_dict.get("extras", {}).iteritems():
extra = model.PackageExtra(key=key, value=value)
package._extras[key] = extra
model.Session.add(package)
model.setup_default_user_roles(package, [])
model.repo.commit_and_remove()
return package
def setup_class(self):
CreateTestData.create()
model.repo.new_revision()
model.Session.add(model.Package(name=u"testpkgag"))
model.Session.add(model.Group(name=u"testgroupag"))
model.Session.add(model.User(name=u"ag_member"))
model.Session.add(model.User(name=u"ag_admin"))
model.Session.add(model.User(name=u"ag_notmember"))
model.Session.add(model.AuthorizationGroup(name=u"authz_group"))
model.repo.commit_and_remove()
pkg = model.Package.by_name(u"testpkgag")
grp = model.Group.by_name(u"testgroupag")
authzgrp = model.AuthorizationGroup.by_name(u"authz_group")
member = model.User.by_name(u"ag_member")
admin = model.User.by_name(u"ag_admin")
model.setup_default_user_roles(authzgrp, [admin])
model.add_authorization_group_to_role(authzgrp, model.Role.ADMIN, pkg)
model.add_authorization_group_to_role(authzgrp, model.Role.ADMIN, grp)
model.add_user_to_authorization_group(member, authzgrp, model.Role.EDITOR)
model.repo.commit_and_remove()
self.authorizer = ckan.authz.Authorizer()
self.pkg = model.Package.by_name(u"testpkgag")
self.grp = model.Group.by_name(u"testgroupag")
self.member = model.User.by_name(u"ag_member")
self.admin = model.User.by_name(u"ag_admin")
self.notmember = model.User.by_name(u"ag_notmember")
self.authzgrp = model.AuthorizationGroup.by_name(u"authz_group")
def create_groups(cls, group_dicts, admin_user_name=None, auth_profile=""):
'''A more featured interface for creating groups.
All group fields can be filled, packages added and they can
have an admin user.'''
import ckan.model as model
rev = model.repo.new_revision()
# same name as user we create below
rev.author = cls.author
if admin_user_name:
admin_users = [model.User.by_name(admin_user_name)]
else:
admin_users = []
assert isinstance(group_dicts, (list, tuple))
group_attributes = set(('name', 'title', 'description', 'parent_id'))
for group_dict in group_dicts:
group = model.Group(name=unicode(group_dict['name']))
group.type = auth_profile or 'group'
for key in group_dict:
if key in group_attributes:
setattr(group, key, group_dict[key])
else:
group.extras[key] = group_dict[key]
pkg_names = group_dict.get('packages', [])
assert isinstance(pkg_names, (list, tuple))
for pkg_name in pkg_names:
pkg = model.Package.by_name(unicode(pkg_name))
assert pkg, pkg_name
member = model.Member(group=group, table_id=pkg.id, table_name='package')
model.Session.add(member)
model.Session.add(group)
model.setup_default_user_roles(group, admin_users)
cls.group_names.add(group_dict['name'])
model.repo.commit_and_remove()
def test_10_edit_pkg_with_download_url(self):
test_params = {
'name':u'testpkg10',
'download_url':u'testurl',
}
rev = model.repo.new_revision()
pkg = model.Package()
model.Session.add(pkg)
pkg.name = test_params['name']
pkg.download_url = test_params['download_url']
model.Session.commit()
pkg = self.get_package_by_name(test_params['name'])
model.setup_default_user_roles(pkg, [self.user])
rev = model.repo.new_revision()
model.repo.commit_and_remove()
assert self.get_package_by_name(test_params['name'])
# edit it
pkg_vals = {'download_url':u'newurl'}
offset = self.package_offset(test_params['name'])
postparams = '%s=1' % self.dumps(pkg_vals)
res = self.app.post(offset, params=postparams, status=[200],
extra_environ=self.admin_extra_environ)
model.Session.remove()
pkg = model.Session.query(model.Package).filter_by(name=test_params['name']).one()
assert len(pkg.resources) == 1, pkg.resources
assert pkg.resources[0].url == pkg_vals['download_url']
def setup_class(self):
# for the authorization editing tests we set up test data so:
# three users, madeup-sysadmin , madeup-administrator, and madeup-another
# one authzgroup
# two packages test6 and test6a, m-a is admin on both
model.repo.init_db()
model.repo.new_revision()
self.sysadmin = 'madeup-sysadmin'
sysadmin_user = model.User(name=unicode(self.sysadmin))
self.admin = 'madeup-administrator'
admin_user = model.User(name=unicode(self.admin))
self.another = u'madeup-another'
another_user = model.User(name=unicode(self.another))
self.authzgroup = u'madeup-authzgroup'
authzgroup = model.AuthorizationGroup(name=unicode(self.authzgroup))
for obj in sysadmin_user, admin_user, another_user, authzgroup:
model.Session.add(obj)
model.add_user_to_role(sysadmin_user, model.Role.ADMIN, model.System())
model.repo.new_revision()
self.pkgname = u'test6'
self.pkgname2 = u'test6a'
pkg = model.Package(name=self.pkgname)
pkg2 = model.Package(name=self.pkgname2)
model.Session.add(pkg)
model.Session.add(pkg2)
admin_user = model.User.by_name(unicode(self.admin))
assert admin_user
model.setup_default_user_roles(pkg, admins=[admin_user])
model.setup_default_user_roles(pkg2, admins=[admin_user])
model.repo.commit_and_remove()
def create_groups(cls, group_dicts, admin_user_name=None, auth_profile=""):
'''A more featured interface for creating groups.
All group fields can be filled, packages added and they can
have an admin user.'''
import ckan.model as model
rev = model.repo.new_revision()
# same name as user we create below
rev.author = cls.author
if admin_user_name:
admin_users = [model.User.by_name(admin_user_name)]
else:
admin_users = []
assert isinstance(group_dicts, (list, tuple))
group_attributes = set(('name', 'title', 'description', 'parent_id'))
for group_dict in group_dicts:
group = model.Group(name=unicode(group_dict['name']))
group.type = auth_profile or 'group'
for key in group_dict:
if key in group_attributes:
setattr(group, key, group_dict[key])
else:
group.extras[key] = group_dict[key]
pkg_names = group_dict.get('packages', [])
assert isinstance(pkg_names, (list, tuple))
for pkg_name in pkg_names:
pkg = model.Package.by_name(unicode(pkg_name))
assert pkg, pkg_name
member = model.Member(group=group, table_id=pkg.id, table_name='package')
model.Session.add(member)
model.Session.add(group)
model.setup_default_user_roles(group, admin_users)
cls.group_names.add(group_dict['name'])
model.repo.commit_and_remove()
def setup_class(self):
model.repo.init_db()
model.repo.new_revision()
self.sysadmin = 'madeup-sysadmin'
sysadmin_user = model.User(name=unicode(self.sysadmin))
self.admin = 'madeup-administrator'
admin_user = model.User(name=unicode(self.admin))
self.another = u'madeup-another'
another_user = model.User(name=unicode(self.another))
for obj in sysadmin_user, admin_user, another_user:
model.Session.add(obj)
model.add_user_to_role(sysadmin_user, model.Role.ADMIN, model.System())
model.repo.new_revision()
self.pkgname = u'test6'
self.pkgname2 = u'test6a'
pkg = model.Package(name=self.pkgname)
pkg2 = model.Package(name=self.pkgname2)
model.Session.add(pkg)
model.Session.add(pkg2)
admin_user = model.User.by_name(unicode(self.admin))
assert admin_user
model.setup_default_user_roles(pkg, admins=[admin_user])
model.setup_default_user_roles(pkg2, admins=[admin_user])
model.repo.commit_and_remove()
def test_11_delete_group(self):
# Test Groups Entity Delete 200.
# create a group with testgroupvalues
group = model.Group.by_name(self.testgroupvalues['name'])
if not group:
rev = model.repo.new_revision()
group = model.Group()
model.Session.add(group)
group.name = self.testgroupvalues['name']
model.repo.commit_and_remove()
rev = model.repo.new_revision()
group = model.Group.by_name(self.testgroupvalues['name'])
model.setup_default_user_roles(group, [self.user])
model.repo.commit_and_remove()
assert group
user = model.User.by_name(self.user_name)
model.setup_default_user_roles(group, [user])
# delete it
offset = self.group_offset(self.testgroupvalues['name'])
res = self.app.delete(offset,
status=[200],
extra_environ=self.extra_environ)
group = model.Group.by_name(self.testgroupvalues['name'])
assert group
assert group.state == 'deleted', group.state
res = self.app.get(offset, status=[403])
self.assert_json_response(res, 'Access denied')
res = self.app.get(offset,
status=[200],
extra_environ=self.extra_environ)
def test_10_edit_group_name_duplicate(self):
# create a group with testgroupvalues
if not model.Group.by_name(self.testgroupvalues['name']):
rev = model.repo.new_revision()
group = model.Group()
model.Session.add(group)
group.name = self.testgroupvalues['name']
model.Session.commit()
group = model.Group.by_name(self.testgroupvalues['name'])
model.setup_default_user_roles(group, [self.user])
rev = model.repo.new_revision()
model.repo.commit_and_remove()
assert model.Group.by_name(self.testgroupvalues['name'])
# create a group with name 'dupname'
dupname = u'dupname'
if not model.Group.by_name(dupname):
rev = model.repo.new_revision()
group = model.Group()
model.Session.add(group)
group.name = dupname
model.Session.commit()
assert model.Group.by_name(dupname)
# edit first group to have dupname
group_vals = {'name': dupname}
offset = self.group_offset(self.testgroupvalues['name'])
postparams = '%s=1' % self.dumps(group_vals)
res = self.app.post(offset,
params=postparams,
status=[409],
extra_environ=self.extra_environ)
self.assert_json_response(res, 'Group name already exists')
def build_creating_revision(self, mark=''):
revision = self.revisions.create_entity(author=u'test', log_message=u'test')
package = self.packages.create_entity(name=u'annie%s'%mark, title=u'Annie Get Your Coat (%s)'%mark)
model.Session.add(package)
model.Session.commit()
model.Session.remove()
setup_default_user_roles(package, [])
self.assert_true(revision.id)
self.assert_true(package.id)
self.assert_true(revision.packages)
return revision.id
def get_groups_identifiers(self, test_groups, users=[]):
groups = []
for grp in test_groups:
group = model.Group.get(grp)
if self.get_expected_api_version() == 1:
groups.append(group.name)
else:
groups.append(group.id)
if users:
model.setup_default_user_roles(group, users)
return groups
def get_groups_identifiers(self, test_groups, users=[]):
groups = []
for grp in test_groups:
group = model.Group.get(grp)
if self.get_expected_api_version() == 1:
groups.append(group.name)
else:
groups.append(group.id)
if users:
model.setup_default_user_roles(group, users)
return groups
def setup_class(self):
model.repo.init_db()
model.repo.new_revision()
self.admin = 'madeup-administrator'
user = model.User(name=unicode(self.admin))
model.Session.add(user)
self.another = u'madeup-another'
model.Session.add(model.User(name=unicode(self.another)))
self.groupname = u'test6'
group = model.Group(name=self.groupname)
model.setup_default_user_roles(group, admins=[user])
model.repo.commit_and_remove()
def create(self):
if not self._check_access(model.System(), model.Action.PACKAGE_CREATE):
return json.dumps(_('Access denied'))
# Create a Package.
fs = self._get_standard_package_fieldset()
try:
request_data = self._get_request_data()
request_fa_dict = ckan.forms.edit_package_dict(ckan.forms.get_package_dict(fs=fs), request_data)
fs = fs.bind(model.Package, data=request_fa_dict, session=model.Session)
log.debug('Created object %s' % str(fs.name.value))
obj = fs.model
# Validate the fieldset.
validation = fs.validate()
if not validation:
# Complain about validation errors.
log.error('Validation error: %r' % repr(fs.errors))
response.write(self._finish(409, repr(fs.errors),
content_type='json'))
else:
try:
# Construct new revision.
rev = model.repo.new_revision()
rev.author = self.rest_api_user
rev.message = _(u'REST API: Create object %s') % str(fs.name.value)
# Construct catalogue entity.
fs.sync()
# Construct access control entities.
if self.rest_api_user:
admins = [model.User.by_name(self.rest_api_user.decode('utf8'))]
else:
admins = []
model.setup_default_user_roles(fs.model, admins)
for item in self.extensions:
item.create(fs.model)
# Commit
model.repo.commit()
# Set location header with new ID.
location = str('%s/%s' % (request.path, obj.id))
response.headers['Location'] = location
log.debug('Response headers: %r' % (response.headers))
response.write(self._finish_ok(
obj.as_dict(),
newly_created_resource_location=location))
except Exception, inst:
log.exception(inst)
model.Session.rollback()
log.error('Exception creating object %s: %r' % (str(fs.name.value), inst))
raise
except ValueError, inst:
response.status_int = 400
response.write(_(u'JSON Error: %s') % str(inst))
def build_creating_revision(self, mark=''):
revision = self.revisions.create_entity(author=u'test',
log_message=u'test')
package = self.packages.create_entity(
name=u'annie%s' % mark, title=u'Annie Get Your Coat (%s)' % mark)
model.Session.add(package)
model.Session.commit()
model.Session.remove()
setup_default_user_roles(package, [])
self.assert_true(revision.id)
self.assert_true(package.id)
self.assert_true(revision.packages)
return revision.id
def setup_class(self):
CreateTestData.create()
model.repo.new_revision()
self.authorizer = authz.Authorizer()
pkg = model.Package(name=u'testpkg')
joeadmin = model.User.by_name(u'joeadmin')
assert joeadmin
model.setup_default_user_roles(pkg, [joeadmin])
model.repo.commit_and_remove()
self.pkg = model.Package.by_name(u'testpkg')
self.joeadmin = model.User.by_name(u'joeadmin')
self.logged_in = model.User.by_name(model.PSEUDO_USER__LOGGED_IN)
self.visitor = model.User.by_name(model.PSEUDO_USER__VISITOR)
def setup_class(self):
CreateTestData.create()
model.repo.new_revision()
self.authorizer = authz.Authorizer()
pkg = model.Package(name=u'testpkg')
joeadmin = model.User.by_name(u'joeadmin')
assert joeadmin
model.setup_default_user_roles(pkg, [joeadmin])
model.repo.commit_and_remove()
self.pkg = model.Package.by_name(u'testpkg')
self.joeadmin = model.User.by_name(u'joeadmin')
self.logged_in = model.User.by_name(model.PSEUDO_USER__LOGGED_IN)
self.visitor = model.User.by_name(model.PSEUDO_USER__VISITOR)
def setup_class(self):
CreateTestData.create()
self.non_active_name = u'test_nonactive'
pkg = model.Package(name=self.non_active_name)
model.repo.new_revision()
model.Session.add(pkg)
model.repo.commit_and_remove()
pkg = model.Session.query(model.Package).filter_by(name=self.non_active_name).one()
admin = model.User.by_name(u'joeadmin')
model.setup_default_user_roles(pkg, [admin])
model.repo.commit_and_remove()
model.repo.new_revision()
pkg = model.Session.query(model.Package).filter_by(name=self.non_active_name).one()
pkg.delete() # becomes non active
model.repo.commit_and_remove()
def setup_class(self):
setup_test_search_index()
CreateTestData.create()
self.non_active_name = u'test_nonactive'
pkg = model.Package(name=self.non_active_name)
model.repo.new_revision()
model.Session.add(pkg)
model.repo.commit_and_remove()
pkg = model.Session.query(model.Package).filter_by(name=self.non_active_name).one()
admin = model.User.by_name(u'joeadmin')
model.setup_default_user_roles(pkg, [admin])
model.repo.commit_and_remove()
model.repo.new_revision()
pkg = model.Session.query(model.Package).filter_by(name=self.non_active_name).one()
pkg.delete() # becomes non active
model.repo.commit_and_remove()
def test_3_edit_form_has_new_package(self):
# check for dataset in autocomplete
offset = url_for(controller='package', action='autocomplete', q='an')
res = self.app.get(offset, status=200, extra_environ={'REMOTE_USER': '******'})
assert 'annakarenina' in res, res
assert not 'newone' in res, res
model.repo.new_revision()
pkg = model.Package(name=u'anewone')
model.Session.add(pkg)
model.repo.commit_and_remove()
model.repo.new_revision()
pkg = model.Package.by_name(u'anewone')
user = model.User.by_name(u'russianfan')
model.setup_default_user_roles(pkg, [user])
model.repo.commit_and_remove()
res = self.app.get(offset, status=200, extra_environ={'REMOTE_USER': '******'})
assert 'annakarenina' in res, res
assert 'newone' in res
def test_3_edit_form_has_new_package(self):
# check for dataset in autocomplete
offset = url_for(controller="package", action="autocomplete", q="an")
res = self.app.get(offset, status=200, extra_environ={"REMOTE_USER": "******"})
assert "annakarenina" in res, res
assert not "newone" in res, res
model.repo.new_revision()
pkg = model.Package(name=u"anewone")
model.Session.add(pkg)
model.repo.commit_and_remove()
model.repo.new_revision()
pkg = model.Package.by_name(u"anewone")
user = model.User.by_name(u"testsysadmin")
model.setup_default_user_roles(pkg, [user])
model.repo.commit_and_remove()
res = self.app.get(offset, status=200, extra_environ={"REMOTE_USER": "******"})
assert "annakarenina" in res, res
assert "newone" in res
def test_3_edit_form_has_new_package(self):
# check for dataset in autocomplete
offset = url_for(controller='package', action='autocomplete', q='an')
res = self.app.get(offset, status=200, extra_environ={'REMOTE_USER': '******'})
assert 'annakarenina' in res, res
assert not 'newone' in res, res
model.repo.new_revision()
pkg = model.Package(name=u'anewone')
model.Session.add(pkg)
model.repo.commit_and_remove()
model.repo.new_revision()
pkg = model.Package.by_name(u'anewone')
user = model.User.by_name(u'russianfan')
model.setup_default_user_roles(pkg, [user])
model.repo.commit_and_remove()
res = self.app.get(offset, status=200, extra_environ={'REMOTE_USER': '******'})
assert 'annakarenina' in res, res
assert 'newone' in res
def test_entity_delete_ok(self):
# create a package with package_fixture_data
if not self.get_package_by_name(self.package_fixture_data['name']):
rev = model.repo.new_revision()
package = model.Package()
model.Session.add(package)
package.name = self.package_fixture_data['name']
model.repo.commit_and_remove()
rev = model.repo.new_revision()
package = self.get_package_by_name(self.package_fixture_data['name'])
model.setup_default_user_roles(package, [self.user])
model.repo.commit_and_remove()
assert self.get_package_by_name(self.package_fixture_data['name'])
# delete it
offset = self.package_offset(self.package_fixture_data['name'])
res = self.app.delete(offset, status=self.STATUS_200_OK,
extra_environ=self.extra_environ)
package = self.get_package_by_name(self.package_fixture_data['name'])
self.assert_equal(package.state, 'deleted')
model.Session.remove()
def test_11_delete_group(self):
# Test Groups Entity Delete 200.
# create a group with testgroupvalues
group = model.Group.by_name(self.testgroupvalues['name'])
if not group:
rev = model.repo.new_revision()
group = model.Group()
model.Session.add(group)
group.name = self.testgroupvalues['name']
model.repo.commit_and_remove()
rev = model.repo.new_revision()
group = model.Group.by_name(self.testgroupvalues['name'])
model.setup_default_user_roles(group, [self.user])
model.repo.commit_and_remove()
assert group
user = model.User.by_name(self.user_name)
model.setup_default_user_roles(group, [user])
# delete it
offset = self.group_offset(self.testgroupvalues['name'])
res = self.app.delete(offset,
status=[200],
extra_environ=self.admin_extra_environ)
res = self.set_env(self.extra_environ)
group = model.Group.by_name(self.testgroupvalues['name'])
assert group
assert group.state == 'deleted', group.state
# Anyone can see groups especially sysadmins
# maybe we want to do something different with
# deleted groups but that would be a new requirement
#res = self.app.get(offset, status=[403])
#self.assert_json_response(res, 'Access denied')
res = self.app.get(offset,
status=[200],
extra_environ=self.admin_extra_environ)
res = self.set_env(self.extra_environ)
def setup_class(cls):
cls.before = datetime.datetime(2010, 1, 1)
cls.date1 = datetime.datetime(2011, 1, 1)
cls.date2 = datetime.datetime(2011, 1, 2)
cls.date3 = datetime.datetime(2011, 1, 3)
cls.today = datetime.datetime.now()
cls.pkg_name = u'testpkg'
# create dataset
rev = model.repo.new_revision()
rev.timestamp = cls.date1
pkg = model.Package(name=cls.pkg_name, title=u'title1')
model.Session.add(pkg)
model.setup_default_user_roles(pkg)
model.repo.commit_and_remove()
# edit dataset
rev = model.repo.new_revision()
rev.timestamp = cls.date2
pkg = model.Package.by_name(cls.pkg_name)
pkg.title = u'title2'
pkg.add_tag_by_name(u'tag 2')
pkg.extras = {'key2': u'value2'}
model.repo.commit_and_remove()
# edit dataset again
rev = model.repo.new_revision()
rev.timestamp = cls.date3
pkg = model.Package.by_name(cls.pkg_name)
pkg.title = u'title3'
pkg.add_tag_by_name(u'tag3.')
pkg.extras['key2'] = u'value3'
model.repo.commit_and_remove()
cls.offset = url_for(controller='package',
action='read',
id=cls.pkg_name)
pkg = model.Package.by_name(cls.pkg_name)
cls.revision_ids = [
rev[0].id for rev in pkg.all_related_revisions[::-1]
]
def setup_class(cls):
cls.before = datetime.datetime(2010, 1, 1)
cls.date1 = datetime.datetime(2011, 1, 1)
cls.date2 = datetime.datetime(2011, 1, 2)
cls.date3 = datetime.datetime(2011, 1, 3)
cls.today = datetime.datetime.now()
cls.pkg_name = u'testpkg'
# create dataset
rev = model.repo.new_revision()
rev.timestamp = cls.date1
pkg = model.Package(name=cls.pkg_name, title=u'title1')
model.Session.add(pkg)
model.setup_default_user_roles(pkg)
model.repo.commit_and_remove()
# edit dataset
rev = model.repo.new_revision()
rev.timestamp = cls.date2
pkg = model.Package.by_name(cls.pkg_name)
pkg.title = u'title2'
pkg.add_tag_by_name(u'tag 2')
pkg.extras = {'key2': u'value2'}
model.repo.commit_and_remove()
# edit dataset again
rev = model.repo.new_revision()
rev.timestamp = cls.date3
pkg = model.Package.by_name(cls.pkg_name)
pkg.title = u'title3'
pkg.add_tag_by_name(u'tag3.')
pkg.extras['key2'] = u'value3'
model.repo.commit_and_remove()
cls.offset = url_for(controller='package',
action='read',
id=cls.pkg_name)
pkg = model.Package.by_name(cls.pkg_name)
cls.revision_ids = [rev[0].id for rev in pkg.all_related_revisions[::-1]]
def test_11_delete_group(self):
# Test Groups Entity Delete 200.
# create a group with testgroupvalues
group = model.Group.by_name(self.testgroupvalues['name'])
if not group:
rev = model.repo.new_revision()
group = model.Group()
model.Session.add(group)
group.name = self.testgroupvalues['name']
model.repo.commit_and_remove()
rev = model.repo.new_revision()
group = model.Group.by_name(self.testgroupvalues['name'])
model.setup_default_user_roles(group, [self.user])
model.repo.commit_and_remove()
assert group
user = model.User.by_name(self.user_name)
model.setup_default_user_roles(group, [user])
# delete it
offset = self.group_offset(self.testgroupvalues['name'])
res = self.app.delete(offset, status=[200],
extra_environ=self.admin_extra_environ)
res = self.set_env(self.extra_environ)
group = model.Group.by_name(self.testgroupvalues['name'])
assert group
assert group.state == 'deleted', group.state
# Anyone can see groups especially sysadmins
# maybe we want to do something different with
# deleted groups but that would be a new requirement
#res = self.app.get(offset, status=[403])
#self.assert_json_response(res, 'Access denied')
res = self.app.get(offset, status=[200],
extra_environ=self.admin_extra_environ)
res = self.set_env(self.extra_environ)
def test_10_edit_group(self):
# create a group with testgroupvalues
group = model.Group.by_name(self.testgroupvalues['name'])
if not group:
offset = self.offset('/rest/group')
postparams = '%s=1' % self.dumps(self.testgroupvalues)
res = self.app.post(offset,
params=postparams,
status=[201],
extra_environ=self.extra_environ)
model.Session.remove()
group = model.Group.by_name(self.testgroupvalues['name'])
assert group
assert len(group.packages) == 2, group.packages
user = model.User.by_name(self.user_name)
model.setup_default_user_roles(group, [user])
# edit it
group_vals = {
'name': u'somethingnew',
'title': u'newtesttitle',
'packages': [u'annakarenina']
}
offset = self.group_offset(self.testgroupvalues['name'])
postparams = '%s=1' % self.dumps(group_vals)
res = self.app.post(offset,
params=postparams,
status=[200],
extra_environ=self.extra_environ)
model.Session.remove()
group = model.Session.query(
model.Group).filter_by(name=group_vals['name']).one()
assert group.name == group_vals['name']
assert group.title == group_vals['title']
assert len(group.packages) == 1, group.packages
assert group.packages[0].name == group_vals['packages'][0]
def test_05b_visitor_creates_package(self):
try:
model.setup_default_user_roles(self.anna, [self.visitor])
except model.NotRealUserException, e:
pass
def create_arbitrary(cls, package_dicts, relationships=[],
extra_user_names=[], extra_group_names=[],
admins=[]):
'''Creates packages and a few extra objects as well at the
same time if required.
@param package_dicts - a list of dictionaries with the package
properties.
Extra keys allowed:
"admins" - list of user names to make admin
for this package.
@param extra_group_names - a list of group names to create. No
properties get set though.
@param admins - a list of user names to make admins of all the
packages created.
'''
assert isinstance(relationships, (list, tuple))
assert isinstance(extra_user_names, (list, tuple))
assert isinstance(extra_group_names, (list, tuple))
model.Session.remove()
new_user_names = extra_user_names
new_group_names = set()
new_groups = {}
admins_list = defaultdict(list) # package_name: admin_names
if package_dicts:
if isinstance(package_dicts, dict):
package_dicts = [package_dicts]
for item in package_dicts:
rev = model.repo.new_revision()
rev.author = cls.author
rev.message = u'Creating test packages.'
pkg_dict = {}
for field in cls.pkg_core_fields:
if item.has_key(field):
pkg_dict[field] = unicode(item[field])
if model.Package.by_name(pkg_dict['name']):
log.warning('Cannot create package "%s" as it already exists.' % \
(pkg_dict['name']))
continue
pkg = model.Package(**pkg_dict)
model.Session.add(pkg)
for attr, val in item.items():
if isinstance(val, str):
val = unicode(val)
if attr=='name':
continue
if attr in cls.pkg_core_fields:
pass
elif attr == 'download_url':
pkg.add_resource(unicode(val))
elif attr == 'resources':
assert isinstance(val, (list, tuple))
for res_dict in val:
non_extras = {}
for k, v in res_dict.items():
if k != 'extras':
if not isinstance(v, datetime.datetime):
v = unicode(v)
non_extras[str(k)] = v
extras = dict([(str(k), unicode(v)) for k, v in res_dict.get('extras', {}).items()])
pkg.add_resource(extras=extras, **non_extras)
elif attr == 'tags':
if isinstance(val, (str, unicode)):
tags = val.split()
elif isinstance(val, list):
tags = val
else:
raise NotImplementedError
for tag_name in tags:
tag_name = unicode(tag_name)
tag = model.Tag.by_name(tag_name)
if not tag:
tag = model.Tag(name=tag_name)
cls.tag_names.append(tag_name)
model.Session.add(tag)
pkg.add_tag(tag)
model.Session.flush()
elif attr == 'groups':
model.Session.flush()
if isinstance(val, (str, unicode)):
group_names = val.split()
elif isinstance(val, list):
group_names = val
else:
raise NotImplementedError
for group_name in group_names:
group = model.Group.by_name(unicode(group_name))
if not group:
if not group_name in new_groups:
group = model.Group(name=unicode(group_name))
model.Session.add(group)
new_group_names.add(group_name)
new_groups[group_name] = group
else:
# If adding multiple packages with the same group name,
# model.Group.by_name will not find the group as the
# session has not yet been committed at this point.
# Fetch from the new_groups dict instead.
group = new_groups[group_name]
member = model.Member(group=group, table_id=pkg.id, table_name='package')
model.Session.add(member)
elif attr == 'license':
pkg.license_id = val
elif attr == 'license_id':
pkg.license_id = val
elif attr == 'extras':
pkg.extras = val
elif attr == 'admins':
assert isinstance(val, list)
admins_list[item['name']].extend(val)
for user_name in val:
if user_name not in new_user_names:
new_user_names.append(user_name)
else:
raise NotImplementedError(attr)
cls.pkg_names.append(item['name'])
model.setup_default_user_roles(pkg, admins=[])
for admin in admins:
admins_list[item['name']].append(admin)
model.repo.commit_and_remove()
needs_commit = False
rev = model.repo.new_revision()
for group_name in extra_group_names:
group = model.Group(name=unicode(group_name))
model.Session.add(group)
new_group_names.add(group_name)
needs_commit = True
if needs_commit:
model.repo.commit_and_remove()
needs_commit = False
# create users that have been identified as being needed
for user_name in new_user_names:
if not model.User.by_name(unicode(user_name)):
user = model.User(name=unicode(user_name))
model.Session.add(user)
cls.user_refs.append(user_name)
needs_commit = True
if needs_commit:
model.repo.commit_and_remove()
needs_commit = False
# setup authz for admins
for pkg_name, admins in admins_list.items():
pkg = model.Package.by_name(unicode(pkg_name))
admins_obj_list = []
for admin in admins:
if isinstance(admin, model.User):
admin_obj = admin
else:
admin_obj = model.User.by_name(unicode(admin))
assert admin_obj, admin
admins_obj_list.append(admin_obj)
model.setup_default_user_roles(pkg, admins_obj_list)
needs_commit = True
# setup authz for groups just created
for group_name in new_group_names:
group = model.Group.by_name(unicode(group_name))
model.setup_default_user_roles(group)
cls.group_names.add(group_name)
needs_commit = True
if needs_commit:
model.repo.commit_and_remove()
needs_commit = False
if relationships:
rev = model.repo.new_revision()
rev.author = cls.author
rev.message = u'Creating package relationships.'
def pkg(pkg_name):
return model.Package.by_name(unicode(pkg_name))
for subject_name, relationship, object_name in relationships:
pkg(subject_name).add_relationship(
unicode(relationship), pkg(object_name))
needs_commit = True
model.repo.commit_and_remove()
def create(cls, auth_profile="", package_type=None):
model.Session.remove()
rev = model.repo.new_revision()
# same name as user we create below
rev.author = cls.author
rev.message = u'''Creating test data.
* Package: annakarenina
* Package: warandpeace
* Associated tags, etc etc
'''
if auth_profile == "publisher":
organization_group = model.Group(name=u"organization_group", type="organization")
cls.pkg_names = [u'annakarenina', u'warandpeace']
pkg1 = model.Package(name=cls.pkg_names[0], type=package_type)
if auth_profile == "publisher":
pkg1.group = organization_group
model.Session.add(pkg1)
pkg1.title = u'A Novel By Tolstoy'
pkg1.version = u'0.7a'
pkg1.url = u'http://www.annakarenina.com'
# put an & in the url string to test escaping
if 'alt_url' in model.Resource.get_extra_columns():
configured_extras = ({'alt_url': u'alt123'},
{'alt_url': u'alt345'})
else:
configured_extras = ({}, {})
pr1 = model.Resource(
url=u'http://www.annakarenina.com/download/x=1&y=2',
format=u'plain text',
description=u'Full text. Needs escaping: " Umlaut: \xfc',
hash=u'abc123',
extras={'size_extra': u'123'},
**configured_extras[0]
)
pr2 = model.Resource(
url=u'http://www.annakarenina.com/index.json',
format=u'json',
description=u'Index of the novel',
hash=u'def456',
extras={'size_extra': u'345'},
**configured_extras[1]
)
model.Session.add(pr1)
model.Session.add(pr2)
pkg1.resource_groups_all[0].resources_all.append(pr1)
pkg1.resource_groups_all[0].resources_all.append(pr2)
pkg1.notes = u'''Some test notes
### A 3rd level heading
**Some bolded text.**
*Some italicized text.*
Foreign characters:
u with umlaut \xfc
66-style quote \u201c
foreign word: th\xfcmb
Needs escaping:
left arrow <
<http://ckan.net/>
'''
pkg2 = model.Package(name=cls.pkg_names[1], type=package_type)
tag1 = model.Tag(name=u'russian')
tag2 = model.Tag(name=u'tolstoy')
if auth_profile == "publisher":
pkg2.group = organization_group
# Flexible tag, allows spaces, upper-case,
# and all punctuation except commas
tag3 = model.Tag(name=u'Flexible \u30a1')
for obj in [pkg2, tag1, tag2, tag3]:
model.Session.add(obj)
pkg1.add_tags([tag1, tag2, tag3])
pkg2.add_tags([ tag1, tag3 ])
cls.tag_names = [ t.name for t in (tag1, tag2, tag3) ]
pkg1.license_id = u'other-open'
pkg2.license_id = u'cc-nc' # closed license
pkg2.title = u'A Wonderful Story'
pkg1.extras = {u'genre':'romantic novel',
u'original media':'book'}
# group
david = model.Group(name=u'david',
title=u'Dave\'s books',
description=u'These are books that David likes.',
type=auth_profile or 'group')
roger = model.Group(name=u'roger',
title=u'Roger\'s books',
description=u'Roger likes these books.',
type=auth_profile or 'group')
for obj in [david, roger]:
model.Session.add(obj)
cls.group_names.add(u'david')
cls.group_names.add(u'roger')
model.Session.flush()
model.Session.add(model.Member(table_id=pkg1.id, table_name='package', group=david))
model.Session.add(model.Member(table_id=pkg2.id, table_name='package', group=david))
model.Session.add(model.Member(table_id=pkg1.id, table_name='package', group=roger))
# authz
sysadmin = model.User(name=u'testsysadmin', password=u'testsysadmin')
sysadmin.sysadmin = True
model.Session.add_all([
model.User(name=u'tester', apikey=u'tester', password=u'tester'),
model.User(name=u'joeadmin', password=u'joeadmin'),
model.User(name=u'annafan', about=u'I love reading Annakarenina. My site: http://anna.com', password=u'annafan'),
model.User(name=u'russianfan', password=u'russianfan'),
sysadmin,
])
cls.user_refs.extend([u'tester', u'joeadmin', u'annafan', u'russianfan', u'testsysadmin'])
model.repo.commit_and_remove()
visitor = model.User.by_name(model.PSEUDO_USER__VISITOR)
anna = model.Package.by_name(u'annakarenina')
war = model.Package.by_name(u'warandpeace')
annafan = model.User.by_name(u'annafan')
russianfan = model.User.by_name(u'russianfan')
model.setup_default_user_roles(anna, [annafan])
model.setup_default_user_roles(war, [russianfan])
model.add_user_to_role(visitor, model.Role.ADMIN, war)
david = model.Group.by_name(u'david')
roger = model.Group.by_name(u'roger')
model.setup_default_user_roles(david, [russianfan])
model.setup_default_user_roles(roger, [russianfan])
model.add_user_to_role(visitor, model.Role.ADMIN, roger)
model.repo.commit_and_remove()
def create(cls, commit_changesets=False):
import ckan.model as model
model.Session.remove()
rev = model.repo.new_revision()
# same name as user we create below
rev.author = cls.author
rev.message = u'''Creating test data.
* Package: annakarenina
* Package: warandpeace
* Associated tags, etc etc
'''
cls.pkg_names = [u'annakarenina', u'warandpeace']
pkg1 = model.Package(name=cls.pkg_names[0])
model.Session.add(pkg1)
pkg1.title = u'A Novel By Tolstoy'
pkg1.version = u'0.7a'
pkg1.url = u'http://www.annakarenina.com'
# put an & in the url string to test escaping
if 'alt_url' in model.Resource.get_extra_columns():
configured_extras = ({
'alt_url': u'alt123'
}, {
'alt_url': u'alt345'
})
else:
configured_extras = ({}, {})
pr1 = model.Resource(
url=u'http://www.annakarenina.com/download/x=1&y=2',
format=u'plain text',
description=u'Full text. Needs escaping: " Umlaut: \xfc',
hash=u'abc123',
extras={'size': u'123'},
**configured_extras[0])
pr2 = model.Resource(url=u'http://www.annakarenina.com/index.json',
format=u'json',
description=u'Index of the novel',
hash=u'def456',
extras={'size': u'345'},
**configured_extras[1])
model.Session.add(pr1)
model.Session.add(pr2)
pkg1.resources.append(pr1)
pkg1.resources.append(pr2)
pkg1.notes = u'''Some test notes
### A 3rd level heading
**Some bolded text.**
*Some italicized text.*
Foreign characters:
u with umlaut \xfc
66-style quote \u201c
foreign word: th\xfcmb
Needs escaping:
left arrow <
<http://ckan.net/>
'''
pkg2 = model.Package(name=cls.pkg_names[1])
tag1 = model.Tag(name=u'russian')
tag2 = model.Tag(name=u'tolstoy')
for obj in [pkg2, tag1, tag2]:
model.Session.add(obj)
pkg1.tags = [tag1, tag2]
pkg2.tags = [tag1]
cls.tag_names = [u'russian', u'tolstoy']
pkg1.license_id = u'other-open'
pkg2.license_id = u'cc-nc' # closed license
pkg2.title = u'A Wonderful Story'
pkg1.extras = {u'genre': 'romantic novel', u'original media': 'book'}
# group
david = model.Group(name=u'david',
title=u'Dave\'s books',
description=u'These are books that David likes.')
roger = model.Group(name=u'roger',
title=u'Roger\'s books',
description=u'Roger likes these books.')
for obj in [david, roger]:
model.Session.add(obj)
cls.group_names.add(u'david')
cls.group_names.add(u'roger')
model.Session.add(model.PackageGroup(package=pkg1, group=david))
model.Session.add(model.PackageGroup(package=pkg2, group=david))
model.Session.add(model.PackageGroup(package=pkg1, group=roger))
# authz
model.Session.add_all([
model.User(name=u'tester', apikey=u'tester', password=u'tester'),
model.User(name=u'joeadmin', password=u'joeadmin'),
model.User(
name=u'annafan',
about=
u'I love reading Annakarenina. My site: <a href="http://anna.com">anna.com</a>',
password=u'annafan'),
model.User(name=u'russianfan', password=u'russianfan'),
model.User(name=u'testsysadmin', password=u'testsysadmin'),
])
cls.user_refs.extend([
u'tester', u'joeadmin', u'annafan', u'russianfan', u'testsysadmin'
])
model.repo.commit_and_remove()
visitor = model.User.by_name(model.PSEUDO_USER__VISITOR)
anna = model.Package.by_name(u'annakarenina')
war = model.Package.by_name(u'warandpeace')
annafan = model.User.by_name(u'annafan')
russianfan = model.User.by_name(u'russianfan')
model.setup_default_user_roles(anna, [annafan])
model.setup_default_user_roles(war, [russianfan])
model.add_user_to_role(visitor, model.Role.ADMIN, war)
david = model.Group.by_name(u'david')
roger = model.Group.by_name(u'roger')
model.setup_default_user_roles(david, [russianfan])
model.setup_default_user_roles(roger, [russianfan])
model.add_user_to_role(visitor, model.Role.ADMIN, roger)
testsysadmin = model.User.by_name(u'testsysadmin')
model.add_user_to_role(testsysadmin, model.Role.ADMIN, model.System())
model.repo.commit_and_remove()
if commit_changesets:
from ckan.model.changeset import ChangesetRegister
changeset_ids = ChangesetRegister().commit()
# Create a couple of authorization groups
for ag_name in [u'anauthzgroup', u'anotherauthzgroup']:
ag = model.AuthorizationGroup.by_name(ag_name)
if not ag: #may already exist, if not create
ag = model.AuthorizationGroup(name=ag_name)
model.Session.add(ag)
model.repo.commit_and_remove()
# and give them a range of roles on various things
ag = model.AuthorizationGroup.by_name(u'anauthzgroup')
aag = model.AuthorizationGroup.by_name(u'anotherauthzgroup')
pkg = model.Package.by_name(u'warandpeace')
g = model.Group.by_name('david')
model.add_authorization_group_to_role(ag, u'editor', model.System())
model.add_authorization_group_to_role(ag, u'reader', pkg)
model.add_authorization_group_to_role(ag, u'admin', aag)
model.add_authorization_group_to_role(aag, u'editor', ag)
model.add_authorization_group_to_role(ag, u'editor', g)
model.repo.commit_and_remove()
def create(cls):
import ckan.model as model
model.Session.remove()
rev = model.repo.new_revision()
# same name as user we create below
rev.author = cls.author
rev.message = u"""Creating test data.
* Package: annakarenina
* Package: warandpeace
* Associated tags, etc etc
"""
cls.pkg_names = [u"annakarenina", u"warandpeace"]
pkg1 = model.Package(name=cls.pkg_names[0])
model.Session.add(pkg1)
pkg1.title = u"A Novel By Tolstoy"
pkg1.version = u"0.7a"
pkg1.url = u"http://www.annakarenina.com"
# put an & in the url string to test escaping
if "alt_url" in model.Resource.get_extra_columns():
configured_extras = ({"alt_url": u"alt123"}, {"alt_url": u"alt345"})
else:
configured_extras = ({}, {})
pr1 = model.Resource(
url=u"http://www.annakarenina.com/download/x=1&y=2",
format=u"plain text",
description=u'Full text. Needs escaping: " Umlaut: \xfc',
hash=u"abc123",
extras={"size_extra": u"123"},
**configured_extras[0]
)
pr2 = model.Resource(
url=u"http://www.annakarenina.com/index.json",
format=u"json",
description=u"Index of the novel",
hash=u"def456",
extras={"size_extra": u"345"},
**configured_extras[1]
)
model.Session.add(pr1)
model.Session.add(pr2)
pkg1.resources.append(pr1)
pkg1.resources.append(pr2)
pkg1.notes = u"""Some test notes
### A 3rd level heading
**Some bolded text.**
*Some italicized text.*
Foreign characters:
u with umlaut \xfc
66-style quote \u201c
foreign word: th\xfcmb
Needs escaping:
left arrow <
<http://ckan.net/>
"""
pkg2 = model.Package(name=cls.pkg_names[1])
tag1 = model.Tag(name=u"russian")
tag2 = model.Tag(name=u"tolstoy")
# Flexible tag, allows spaces, upper-case,
# and all punctuation except commas
tag3 = model.Tag(name=u"Flexible \u30a1")
for obj in [pkg2, tag1, tag2, tag3]:
model.Session.add(obj)
pkg1.tags = [tag1, tag2, tag3]
pkg2.tags = [tag1, tag3]
cls.tag_names = [t.name for t in (tag1, tag2, tag3)]
pkg1.license_id = u"other-open"
pkg2.license_id = u"cc-nc" # closed license
pkg2.title = u"A Wonderful Story"
pkg1.extras = {u"genre": "romantic novel", u"original media": "book"}
# group
david = model.Group(name=u"david", title=u"Dave's books", description=u"These are books that David likes.")
roger = model.Group(name=u"roger", title=u"Roger's books", description=u"Roger likes these books.")
for obj in [david, roger]:
model.Session.add(obj)
cls.group_names.add(u"david")
cls.group_names.add(u"roger")
model.Session.add(model.PackageGroup(package=pkg1, group=david))
model.Session.add(model.PackageGroup(package=pkg2, group=david))
model.Session.add(model.PackageGroup(package=pkg1, group=roger))
# authz
model.Session.add_all(
[
model.User(name=u"tester", apikey=u"tester", password=u"tester"),
model.User(name=u"joeadmin", password=u"joeadmin"),
model.User(
name=u"annafan",
about=u'I love reading Annakarenina. My site: <a href="http://anna.com">anna.com</a>',
password=u"annafan",
),
model.User(name=u"russianfan", password=u"russianfan"),
model.User(name=u"testsysadmin", password=u"testsysadmin"),
]
)
cls.user_refs.extend([u"tester", u"joeadmin", u"annafan", u"russianfan", u"testsysadmin"])
model.repo.commit_and_remove()
visitor = model.User.by_name(model.PSEUDO_USER__VISITOR)
anna = model.Package.by_name(u"annakarenina")
war = model.Package.by_name(u"warandpeace")
annafan = model.User.by_name(u"annafan")
russianfan = model.User.by_name(u"russianfan")
model.setup_default_user_roles(anna, [annafan])
model.setup_default_user_roles(war, [russianfan])
model.add_user_to_role(visitor, model.Role.ADMIN, war)
david = model.Group.by_name(u"david")
roger = model.Group.by_name(u"roger")
model.setup_default_user_roles(david, [russianfan])
model.setup_default_user_roles(roger, [russianfan])
model.add_user_to_role(visitor, model.Role.ADMIN, roger)
testsysadmin = model.User.by_name(u"testsysadmin")
model.add_user_to_role(testsysadmin, model.Role.ADMIN, model.System())
model.repo.commit_and_remove()
# Create a couple of authorization groups
for ag_name in [u"anauthzgroup", u"anotherauthzgroup"]:
ag = model.AuthorizationGroup.by_name(ag_name)
if not ag: # may already exist, if not create
ag = model.AuthorizationGroup(name=ag_name)
model.Session.add(ag)
model.repo.commit_and_remove()
# and give them a range of roles on various things
ag = model.AuthorizationGroup.by_name(u"anauthzgroup")
aag = model.AuthorizationGroup.by_name(u"anotherauthzgroup")
pkg = model.Package.by_name(u"warandpeace")
g = model.Group.by_name("david")
model.add_authorization_group_to_role(ag, u"editor", model.System())
model.add_authorization_group_to_role(ag, u"reader", pkg)
model.add_authorization_group_to_role(ag, u"admin", aag)
model.add_authorization_group_to_role(aag, u"editor", ag)
model.add_authorization_group_to_role(ag, u"editor", g)
model.repo.commit_and_remove()
def package_create(context, data_dict):
'''Create a new dataset (package).
You must be authorized to create new datasets. If you specify any groups
for the new dataset, you must also be authorized to edit these groups.
Plugins may change the parameters of this function depending on the value
of the ``type`` parameter, see the ``IDatasetForm`` plugin interface.
:param name: the name of the new dataset, must be between 2 and 100
characters long and contain only lowercase alphanumeric characters,
``-`` and ``_``, e.g. ``'warandpeace'``
:type name: string
:param title: the title of the dataset (optional, default: same as
``name``)
:type title: string
:param author: the name of the dataset's author (optional)
:type author: string
:param author_email: the email address of the dataset's author (optional)
:type author_email: string
:param maintainer: the name of the dataset's maintainer (optional)
:type maintainer: string
:param maintainer_email: the email address of the dataset's maintainer
(optional)
:type maintainer_email: string
:param license_id: the id of the dataset's license, see ``license_list()``
for available values (optional)
:type license_id: license id string
:param notes: a description of the dataset (optional)
:type notes: string
:param url: a URL for the dataset's source (optional)
:type url: string
:param version: (optional)
:type version: string, no longer than 100 characters
:param state: the current state of the dataset, e.g. ``'active'`` or
``'deleted'``, only active datasets show up in search results and
other lists of datasets, this parameter will be ignored if you are not
authorized to change the state of the dataset (optional, default:
``'active'``)
:type state: string
:param type: the type of the dataset (optional), ``IDatasetForm`` plugins
associate themselves with different dataset types and provide custom
dataset handling behaviour for these types
:type type: string
:param resources: the dataset's resources, see ``resource_create()``
for the format of resource dictionaries (optional)
:type resources: list of resource dictionaries
:param tags: the dataset's tags, see ``tag_create()`` for the format
of tag dictionaries (optional)
:type tags: list of tag dictionaries
:param extras: the dataset's extras (optional), extras are arbitrary
(key: value) metadata items that can be added to datasets, each extra
dictionary should have keys ``'key'`` (a string), ``'value'`` (a
string)
:type extras: list of dataset extra dictionaries
:param relationships_as_object: see ``package_relationship_create()`` for
the format of relationship dictionaries (optional)
:type relationships_as_object: list of relationship dictionaries
:param relationships_as_subject: see ``package_relationship_create()`` for
the format of relationship dictionaries (optional)
:type relationships_as_subject: list of relationship dictionaries
:param groups: the groups to which the dataset belongs (optional), each
group dictionary should have one or more of the following keys which
identify an existing group:
``'id'`` (the id of the group, string), ``'name'`` (the name of the
group, string), ``'title'`` (the title of the group, string), to see
which groups exist call ``group_list()``
:type groups: list of dictionaries
:param owner_org: the id of the dataset's owning organization, see
``organization_list()`` or ``organization_list_for_user`` for
available values (optional)
:type owner_org: string
:returns: the newly created dataset (unless 'return_id_only' is set to True
in the context, in which case just the dataset id will be returned)
:rtype: dictionary
'''
model = context['model']
user = context['user']
log.info('context: %s', context)
package_type = data_dict.get('type')
package_plugin = lib_plugins.lookup_package_plugin(package_type)
if 'schema' in context:
schema = context['schema']
else:
schema = package_plugin.create_package_schema()
_check_access('package_create', context, data_dict)
if 'api_version' not in context:
# check_data_dict() is deprecated. If the package_plugin has a
# check_data_dict() we'll call it, if it doesn't have the method we'll
# do nothing.
check_data_dict = getattr(package_plugin, 'check_data_dict', None)
if check_data_dict:
try:
check_data_dict(data_dict, schema)
except TypeError:
# Old plugins do not support passing the schema so we need
# to ensure they still work
package_plugin.check_data_dict(data_dict)
#we cannot modify model but we can ensure no modification via GUI/API
delete_keys = ['author_email', 'maintainer', 'maintainer_email']
for key in delete_keys:
if key in data_dict:
del data_dict[key]
data, errors = _validate(data_dict, schema, context)
log.debug('package_create validate_errs=%r user=%s package=%s data=%r',
errors, context.get('user'), data.get('name'), data_dict)
if errors:
model.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")
admins = []
if user:
user_obj = model.User.by_name(user.decode('utf8'))
if user_obj:
admins = [user_obj]
data['creator_user_id'] = user_obj.id
pkg = model_save.package_dict_save(data, context)
model.setup_default_user_roles(pkg, admins)
# Needed to let extensions know the package id
model.Session.flush()
data['id'] = pkg.id
context_org_update = context.copy()
context_org_update['ignore_auth'] = True
context_org_update['defer_commit'] = True
_get_action('package_owner_org_update')(context_org_update, {
'id': pkg.id,
'organization_id': pkg.owner_org
})
for item in plugins.PluginImplementations(plugins.IPackageController):
item.create(pkg)
item.after_create(context, data)
if not context.get('defer_commit'):
model.repo.commit()
## need to let rest api create
context["package"] = pkg
## this is added so that the rest controller can make a new location
context["id"] = pkg.id
log.debug('Created object %s' % pkg.name)
# Make sure that a user provided schema is not used on package_show
context.pop('schema', None)
return_id_only = context.get('return_id_only', False)
output = context['id'] if return_id_only \
else _get_action('package_show')(context, {'id':context['id']})
_get_action('notify_package_create')(context, data_dict)
audit_helper(data_dict, output, 'package_create')
return output
def logic_action_create_package_create(context, data_dict):
'''Create a new dataset (package).
You must be authorized to create new datasets. If you specify any groups
for the new dataset, you must also be authorized to edit these groups.
Plugins may change the parameters of this function depending on the value
of the ``type`` parameter, see the
:py:class:`~ckan.plugins.interfaces.IDatasetForm` plugin interface.
:param name: the name of the new dataset, must be between 2 and 100
characters long and contain only lowercase alphanumeric characters,
``-`` and ``_``, e.g. ``'warandpeace'``
:type name: string
:param title: the title of the dataset (optional, default: same as
``name``)
:type title: string
:param author: the name of the dataset's author (optional)
:type author: string
:param author_email: the email address of the dataset's author (optional)
:type author_email: string
:param maintainer: the name of the dataset's maintainer (optional)
:type maintainer: string
:param maintainer_email: the email address of the dataset's maintainer
(optional)
:type maintainer_email: string
:param license_id: the id of the dataset's license, see
:py:func:`~ckan.logic.action.get.license_list` for available values
(optional)
:type license_id: license id string
:param notes: a description of the dataset (optional)
:type notes: string
:param url: a URL for the dataset's source (optional)
:type url: string
:param version: (optional)
:type version: string, no longer than 100 characters
:param state: the current state of the dataset, e.g. ``'active'`` or
``'deleted'``, only active datasets show up in search results and
other lists of datasets, this parameter will be ignored if you are not
authorized to change the state of the dataset (optional, default:
``'active'``)
:type state: string
:param type: the type of the dataset (optional),
:py:class:`~ckan.plugins.interfaces.IDatasetForm` plugins
associate themselves with different dataset types and provide custom
dataset handling behaviour for these types
:type type: string
:param resources: the dataset's resources, see
:py:func:`resource_create` for the format of resource dictionaries
(optional)
:type resources: list of resource dictionaries
:param tags: the dataset's tags, see :py:func:`tag_create` for the format
of tag dictionaries (optional)
:type tags: list of tag dictionaries
:param extras: the dataset's extras (optional), extras are arbitrary
(key: value) metadata items that can be added to datasets, each extra
dictionary should have keys ``'key'`` (a string), ``'value'`` (a
string)
:type extras: list of dataset extra dictionaries
:param relationships_as_object: see :py:func:`package_relationship_create`
for the format of relationship dictionaries (optional)
:type relationships_as_object: list of relationship dictionaries
:param relationships_as_subject: see :py:func:`package_relationship_create`
for the format of relationship dictionaries (optional)
:type relationships_as_subject: list of relationship dictionaries
:param groups: the groups to which the dataset belongs (optional), each
group dictionary should have one or more of the following keys which
identify an existing group:
``'id'`` (the id of the group, string), or ``'name'`` (the name of the
group, string), to see which groups exist
call :py:func:`~ckan.logic.action.get.group_list`
:type groups: list of dictionaries
:param owner_org: the id of the dataset's owning organization, see
:py:func:`~ckan.logic.action.get.organization_list` or
:py:func:`~ckan.logic.action.get.organization_list_for_user` for
available values (optional)
:type owner_org: string
:returns: the newly created dataset (unless 'return_id_only' is set to True
in the context, in which case just the dataset id will
be returned)
:rtype: dictionary
'''
import ckan.lib.plugins as lib_plugins
import datetime
import ckan.lib.dictization.model_save as model_save
import ckan.plugins as plugins
import ckan.lib.uploader as uploader
_check_access = ckan.logic.check_access
model = context['model']
user = context['user']
if 'type' not in data_dict:
package_plugin = lib_plugins.lookup_package_plugin()
try:
# use first type as default if user didn't provide type
package_type = package_plugin.package_types()[0]
except (AttributeError, IndexError):
package_type = 'dataset'
# in case a 'dataset' plugin was registered w/o fallback
package_plugin = lib_plugins.lookup_package_plugin(package_type)
data_dict['type'] = package_type
else:
package_plugin = lib_plugins.lookup_package_plugin(data_dict['type'])
if 'schema' in context:
schema = context['schema']
else:
schema = package_plugin.create_package_schema()
upload = uploader.Upload('package', '')
upload.update_data_dict(data_dict, 'image_url', 'image_upload',
'clear_upload')
_check_access('package_create', context, data_dict)
if 'api_version' not in context:
# check_data_dict() is deprecated. If the package_plugin has a
# check_data_dict() we'll call it, if it doesn't have the method we'll
# do nothing.
check_data_dict = getattr(package_plugin, 'check_data_dict', None)
if check_data_dict:
try:
check_data_dict(data_dict, schema)
except TypeError:
# Old plugins do not support passing the schema so we need
# to ensure they still work
package_plugin.check_data_dict(data_dict)
data, errors = lib_plugins.plugin_validate(package_plugin, context,
data_dict, schema,
'package_create')
log.debug('package_create validate_errs=%r user=%s package=%s data=%r',
errors, context.get('user'), data.get('name'), data_dict)
if errors:
model.Session.rollback()
raise ckan.logic.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")
admins = []
if user:
user_obj = model.User.by_name(user.decode('utf8'))
if user_obj:
admins = [user_obj]
data['creator_user_id'] = user_obj.id
upload.upload(uploader.get_max_image_size())
generateThumbs(upload.filepath)
if 'raw_image_url' in data_dict:
data['extras'].append({
'key': 'image_url',
'value': data_dict['raw_image_url']
})
generateThumbs(
config.get('ckan.storage_path') + '/storage/uploads/package/' +
data_dict['raw_image_url'])
pkg = model_save.package_dict_save(data, context)
model.setup_default_user_roles(pkg, admins)
# Needed to let extensions know the package and resources ids
model.Session.flush()
data['id'] = pkg.id
if data.get('resources'):
for index, resource in enumerate(data['resources']):
resource['id'] = pkg.resources[index].id
context_org_update = context.copy()
context_org_update['ignore_auth'] = True
context_org_update['defer_commit'] = True
ckan.logic.get_action('package_owner_org_update')(
context_org_update, {
'id': pkg.id,
'organization_id': pkg.owner_org
})
for item in plugins.PluginImplementations(plugins.IPackageController):
item.create(pkg)
item.after_create(context, data)
# Make sure that a user provided schema is not used in create_views
# and on package_show
context.pop('schema', None)
# Create default views for resources if necessary
if data.get('resources'):
ckan.logic.get_action('package_create_default_resource_views')(
{
'model': context['model'],
'user': context['user'],
'ignore_auth': True
}, {
'package': data
})
if not context.get('defer_commit'):
model.repo.commit()
## need to let rest api create
context["package"] = pkg
## this is added so that the rest controller can make a new location
context["id"] = pkg.id
log.debug('Created object %s' % pkg.name)
return_id_only = context.get('return_id_only', False)
output = context['id'] if return_id_only \
else ckan.logic.get_action('package_show')(context, {'id': context['id']})
return output
def setup_class(self):
model.Session.remove()
CreateTestData.create()
model.Session.remove()
self.authorizer = authz.Authorizer()
self.admin_role = model.Role.ADMIN
self.editor_role = model.Role.EDITOR
self.reader_role = model.Role.READER
john = model.User(name=u'john')
model.Session.add(john)
# setup annakarenina with default roles
anna = model.Package.by_name(u'annakarenina')
model.clear_user_roles(anna)
annakarenina_creator = model.User(name=u'annakarenina_creator')
model.Session.add(annakarenina_creator)
model.repo.commit_and_remove()
model.setup_default_user_roles(anna, [annakarenina_creator])
model.repo.commit_and_remove()
# setup warandpeace with no roles
war = model.Package.by_name(u'warandpeace')
model.clear_user_roles(war)
# setup restricted package - visitors can't change
restricted = model.Package(name=u'restricted')
vrestricted = model.Package(name=u'vrestricted')
mreditor = model.User(name=u'mreditor')
mrreader = model.User(name=u'mrreader')
self.mrsysadmin = u'mrsysadmin'
mrsysadmin = model.User(name=self.mrsysadmin)
model.repo.new_revision()
model.Session.add_all([restricted,
vrestricted,mreditor,mrreader,mrsysadmin])
model.repo.commit_and_remove()
visitor_roles = []
logged_in_roles = [model.Role.EDITOR, model.Role.READER]
logged_in_roles_v = []
restricted = model.Package.by_name(u'restricted')
vrestricted = model.Package.by_name(u'vrestricted')
model.setup_user_roles(restricted, visitor_roles, logged_in_roles)
model.setup_user_roles(vrestricted, visitor_roles, logged_in_roles_v)
model.repo.commit_and_remove()
mreditor = model.User.by_name(u'mreditor')
model.add_user_to_role(mreditor, model.Role.EDITOR, restricted)
mrsysadmin = model.User.by_name(u'mrsysadmin')
model.add_user_to_role(mrsysadmin, model.Role.ADMIN, model.System())
model.repo.commit_and_remove()
self.mreditor = model.User.by_name(u'mreditor')
self.mrreader = model.User.by_name(u'mrreader')
self.annakarenina_creator = model.User.by_name(u'annakarenina_creator')
self.logged_in = model.User.by_name(model.PSEUDO_USER__LOGGED_IN)
self.visitor = model.User.by_name(model.PSEUDO_USER__VISITOR)
self.john = model.User.by_name(u'john')
self.war = model.Package.by_name(u'warandpeace')
self.anna = model.Package.by_name(u'annakarenina')
self.restricted = model.Package.by_name(u'restricted')
self.vrestricted = model.Package.by_name(u'vrestricted')
def test_05b_visitor_creates_package(self):
try:
model.setup_default_user_roles(self.anna, [self.visitor])
except model.NotRealUserException, e:
pass
def setup_class(self):
model.Session.remove()
CreateTestData.create()
model.Session.remove()
self.authorizer = authz.Authorizer()
self.admin_role = model.Role.ADMIN
self.editor_role = model.Role.EDITOR
self.reader_role = model.Role.READER
john = model.User(name=u'john')
model.Session.add(john)
# setup annakarenina with default roles
anna = model.Package.by_name(u'annakarenina')
model.clear_user_roles(anna)
annakarenina_creator = model.User(name=u'annakarenina_creator')
model.Session.add(annakarenina_creator)
model.repo.commit_and_remove()
model.setup_default_user_roles(anna, [annakarenina_creator])
model.repo.commit_and_remove()
# setup warandpeace with no roles
war = model.Package.by_name(u'warandpeace')
model.clear_user_roles(war)
# setup restricted package - visitors can't change
restricted = model.Package(name=u'restricted')
vrestricted = model.Package(name=u'vrestricted')
mreditor = model.User(name=u'mreditor')
mrreader = model.User(name=u'mrreader')
self.mrsysadmin = u'mrsysadmin'
mrsysadmin = model.User(name=self.mrsysadmin)
model.repo.new_revision()
model.Session.add_all(
[restricted, vrestricted, mreditor, mrreader, mrsysadmin])
model.repo.commit_and_remove()
visitor_roles = []
logged_in_roles = [model.Role.EDITOR, model.Role.READER]
logged_in_roles_v = []
restricted = model.Package.by_name(u'restricted')
vrestricted = model.Package.by_name(u'vrestricted')
model.setup_user_roles(restricted, visitor_roles, logged_in_roles)
model.setup_user_roles(vrestricted, visitor_roles, logged_in_roles_v)
model.repo.commit_and_remove()
mreditor = model.User.by_name(u'mreditor')
model.add_user_to_role(mreditor, model.Role.EDITOR, restricted)
mrsysadmin = model.User.by_name(u'mrsysadmin')
model.add_user_to_role(mrsysadmin, model.Role.ADMIN, model.System())
model.repo.commit_and_remove()
self.mreditor = model.User.by_name(u'mreditor')
self.mrreader = model.User.by_name(u'mrreader')
self.annakarenina_creator = model.User.by_name(u'annakarenina_creator')
self.logged_in = model.User.by_name(model.PSEUDO_USER__LOGGED_IN)
self.visitor = model.User.by_name(model.PSEUDO_USER__VISITOR)
self.john = model.User.by_name(u'john')
self.war = model.Package.by_name(u'warandpeace')
self.anna = model.Package.by_name(u'annakarenina')
self.restricted = model.Package.by_name(u'restricted')
self.vrestricted = model.Package.by_name(u'vrestricted')
def create_package_from_data(self, package_data, package=None):
''' {"extras": {"INSPIRE": "True",
"bbox-east-long": "-3.12442",
"bbox-north-lat": "54.218407",
"bbox-south-lat": "54.039634",
"bbox-west-long": "-3.32485",
"constraint": "conditions unknown; (e) intellectual property rights;",
"dataset-reference-date": [{"type": "creation",
"value": "2008-10-10"},
{"type": "revision",
"value": "2009-10-08"}],
"guid": "00a743bf-cca4-4c19-a8e5-e64f7edbcadd",
"metadata-date": "2009-10-16",
"metadata-language": "eng",
"published_by": 0,
"resource-type": "dataset",
"spatial-reference-system": "wee",
"temporal_coverage-from": "1977-03-10T11:45:30",
"temporal_coverage-to": "2005-01-15T09:10:00"},
"name": "council-owned-litter-bins",
"notes": "Location of Council owned litter bins within Borough.",
"resources": [{"description": "Resource locator",
"format": "Unverified",
"url": "http://www.barrowbc.gov.uk"}],
"tags": ["Utility and governmental services"],
"title": "Council Owned Litter Bins"}
'''
if not package:
package = model.Package()
rev = model.repo.new_revision()
relationship_attr = ['extras', 'resources', 'tags']
package_properties = {}
for key, value in package_data.iteritems():
if key not in relationship_attr:
setattr(package, key, value)
tags = package_data.get('tags', [])
for tag in tags:
package.add_tag_by_name(tag, autoflush=False)
for resource_dict in package_data.get("resources", []):
resource = model.Resource(**resource_dict)
package.resources[:] = []
package.resources.append(resource)
for key, value in package_data.get("extras", {}).iteritems():
extra = model.PackageExtra(key=key, value=value)
package._extras[key] = extra
model.Session.add(package)
model.Session.flush()
model.setup_default_user_roles(package, [])
model.Session.add(rev)
model.Session.commit()
return package
def package_create(context, data_dict):
"""Create a new dataset (package).
You must be authorized to create new datasets. If you specify any groups
for the new dataset, you must also be authorized to edit these groups.
Plugins may change the parameters of this function depending on the value
of the ``type`` parameter, see the ``IDatasetForm`` plugin interface.
:param name: the name of the new dataset, must be between 2 and 100
characters long and contain only lowercase alphanumeric characters,
``-`` and ``_``, e.g. ``'warandpeace'``
:type name: string
:param title: the title of the dataset (optional, default: same as
``name``)
:type title: string
:param author: the name of the dataset's author (optional)
:type author: string
:param author_email: the email address of the dataset's author (optional)
:type author_email: string
:param maintainer: the name of the dataset's maintainer (optional)
:type maintainer: string
:param maintainer_email: the email address of the dataset's maintainer
(optional)
:type maintainer_email: string
:param license_id: the id of the dataset's license, see ``license_list()``
for available values (optional)
:type license_id: license id string
:param notes: a description of the dataset (optional)
:type notes: string
:param url: a URL for the dataset's source (optional)
:type url: string
:param version: (optional)
:type version: string, no longer than 100 characters
:param state: the current state of the dataset, e.g. ``'active'`` or
``'deleted'``, only active datasets show up in search results and
other lists of datasets, this parameter will be ignored if you are not
authorized to change the state of the dataset (optional, default:
``'active'``)
:type state: string
:param type: the type of the dataset (optional), ``IDatasetForm`` plugins
associate themselves with different dataset types and provide custom
dataset handling behaviour for these types
:type type: string
:param resources: the dataset's resources, see ``resource_create()``
for the format of resource dictionaries (optional)
:type resources: list of resource dictionaries
:param tags: the dataset's tags, see ``tag_create()`` for the format
of tag dictionaries (optional)
:type tags: list of tag dictionaries
:param extras: the dataset's extras (optional), extras are arbitrary
(key: value) metadata items that can be added to datasets, each extra
dictionary should have keys ``'key'`` (a string), ``'value'`` (a
string)
:type extras: list of dataset extra dictionaries
:param relationships_as_object: see ``package_relationship_create()`` for
the format of relationship dictionaries (optional)
:type relationships_as_object: list of relationship dictionaries
:param relationships_as_subject: see ``package_relationship_create()`` for
the format of relationship dictionaries (optional)
:type relationships_as_subject: list of relationship dictionaries
:param groups: the groups to which the dataset belongs (optional), each
group dictionary should have one or more of the following keys which
identify an existing group:
``'id'`` (the id of the group, string), ``'name'`` (the name of the
group, string), ``'title'`` (the title of the group, string), to see
which groups exist call ``group_list()``
:type groups: list of dictionaries
:param owner_org: the id of the dataset's owning organization, see
``organization_list()`` or ``organization_list_for_user`` for
available values (optional)
:type owner_org: string
:returns: the newly created dataset (unless 'return_id_only' is set to True
in the context, in which case just the dataset id will be returned)
:rtype: dictionary
"""
model = context["model"]
user = context["user"]
package_type = data_dict.get("type")
package_plugin = lib_plugins.lookup_package_plugin(package_type)
if "schema" in context:
schema = context["schema"]
else:
schema = package_plugin.create_package_schema()
_check_access("package_create", context, data_dict)
if "api_version" not in context:
# check_data_dict() is deprecated. If the package_plugin has a
# check_data_dict() we'll call it, if it doesn't have the method we'll
# do nothing.
check_data_dict = getattr(package_plugin, "check_data_dict", None)
if check_data_dict:
try:
check_data_dict(data_dict, schema)
except TypeError:
# Old plugins do not support passing the schema so we need
# to ensure they still work
package_plugin.check_data_dict(data_dict)
data, errors = _validate(data_dict, schema, context)
if "tags" in data:
data["tags"] = get_tag_vocabulary(data["tags"])
if "groups" in data:
data["extras"].append({"key": "solr_additions", "value": build_additions(data["groups"])})
log.debug(
"package_create validate_errs=%r user=%s package=%s data=%r",
errors,
context.get("user"),
data.get("name"),
data_dict,
)
if errors:
model.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")
admins = []
if user:
user_obj = model.User.by_name(user.decode("utf8"))
if user_obj:
admins = [user_obj]
data["creator_user_id"] = user_obj.id
pkg = model_save.package_dict_save(data, context)
model.setup_default_user_roles(pkg, admins)
# Needed to let extensions know the package id
model.Session.flush()
data["id"] = pkg.id
context_org_update = context.copy()
context_org_update["ignore_auth"] = True
context_org_update["defer_commit"] = True
_get_action("package_owner_org_update")(context_org_update, {"id": pkg.id, "organization_id": pkg.owner_org})
for item in plugins.PluginImplementations(plugins.IPackageController):
item.create(pkg)
item.after_create(context, data)
if not context.get("defer_commit"):
model.repo.commit()
# need to let rest api create
context["package"] = pkg
# this is added so that the rest controller can make a new location
context["id"] = pkg.id
log.debug("Created object %s" % pkg.name)
# Make sure that a user provided schema is not used on package_show
context.pop("schema", None)
return_id_only = context.get("return_id_only", False)
output = context["id"] if return_id_only else _get_action("package_show")(context, {"id": context["id"]})
return output
def create(cls, auth_profile="", package_type=None):
model.Session.remove()
rev = model.repo.new_revision()
# same name as user we create below
rev.author = cls.author
rev.message = u'''Creating test data.
* Package: annakarenina
* Package: warandpeace
* Associated tags, etc etc
'''
if auth_profile == "publisher":
organization_group = model.Group(name=u"organization_group",
type="organization")
cls.pkg_names = [u'annakarenina', u'warandpeace']
pkg1 = model.Package(name=cls.pkg_names[0], type=package_type)
if auth_profile == "publisher":
pkg1.group = organization_group
model.Session.add(pkg1)
pkg1.title = u'A Novel By Tolstoy'
pkg1.version = u'0.7a'
pkg1.url = u'http://www.annakarenina.com'
# put an & in the url string to test escaping
if 'alt_url' in model.Resource.get_extra_columns():
configured_extras = ({
'alt_url': u'alt123'
}, {
'alt_url': u'alt345'
})
else:
configured_extras = ({}, {})
pr1 = model.Resource(
url=u'http://www.annakarenina.com/download/x=1&y=2',
format=u'plain text',
description=u'Full text. Needs escaping: " Umlaut: \xfc',
hash=u'abc123',
extras={'size_extra': u'123'},
**configured_extras[0])
pr2 = model.Resource(url=u'http://www.annakarenina.com/index.json',
format=u'json',
description=u'Index of the novel',
hash=u'def456',
extras={'size_extra': u'345'},
**configured_extras[1])
model.Session.add(pr1)
model.Session.add(pr2)
pkg1.resource_groups_all[0].resources_all.append(pr1)
pkg1.resource_groups_all[0].resources_all.append(pr2)
pkg1.notes = u'''Some test notes
### A 3rd level heading
**Some bolded text.**
*Some italicized text.*
Foreign characters:
u with umlaut \xfc
66-style quote \u201c
foreign word: th\xfcmb
Needs escaping:
left arrow <
<http://ckan.net/>
'''
pkg2 = model.Package(name=cls.pkg_names[1], type=package_type)
tag1 = model.Tag(name=u'russian')
tag2 = model.Tag(name=u'tolstoy')
if auth_profile == "publisher":
pkg2.group = organization_group
# Flexible tag, allows spaces, upper-case,
# and all punctuation except commas
tag3 = model.Tag(name=u'Flexible \u30a1')
for obj in [pkg2, tag1, tag2, tag3]:
model.Session.add(obj)
pkg1.add_tags([tag1, tag2, tag3])
pkg2.add_tags([tag1, tag3])
cls.tag_names = [t.name for t in (tag1, tag2, tag3)]
pkg1.license_id = u'other-open'
pkg2.license_id = u'cc-nc' # closed license
pkg2.title = u'A Wonderful Story'
pkg1.extras = {u'genre': 'romantic novel', u'original media': 'book'}
# group
david = model.Group(name=u'david',
title=u'Dave\'s books',
description=u'These are books that David likes.',
type=auth_profile or 'group')
roger = model.Group(name=u'roger',
title=u'Roger\'s books',
description=u'Roger likes these books.',
type=auth_profile or 'group')
for obj in [david, roger]:
model.Session.add(obj)
cls.group_names.add(u'david')
cls.group_names.add(u'roger')
model.Session.flush()
model.Session.add(
model.Member(table_id=pkg1.id, table_name='package', group=david))
model.Session.add(
model.Member(table_id=pkg2.id, table_name='package', group=david))
model.Session.add(
model.Member(table_id=pkg1.id, table_name='package', group=roger))
# authz
sysadmin = model.User(name=u'testsysadmin', password=u'testsysadmin')
sysadmin.sysadmin = True
model.Session.add_all([
model.User(name=u'tester', apikey=u'tester', password=u'tester'),
model.User(name=u'joeadmin', password=u'joeadmin'),
model.User(
name=u'annafan',
about=u'I love reading Annakarenina. My site: http://anna.com',
password=u'annafan'),
model.User(name=u'russianfan', password=u'russianfan'),
sysadmin,
])
cls.user_refs.extend([
u'tester', u'joeadmin', u'annafan', u'russianfan', u'testsysadmin'
])
model.repo.commit_and_remove()
visitor = model.User.by_name(model.PSEUDO_USER__VISITOR)
anna = model.Package.by_name(u'annakarenina')
war = model.Package.by_name(u'warandpeace')
annafan = model.User.by_name(u'annafan')
russianfan = model.User.by_name(u'russianfan')
model.setup_default_user_roles(anna, [annafan])
model.setup_default_user_roles(war, [russianfan])
model.add_user_to_role(visitor, model.Role.ADMIN, war)
david = model.Group.by_name(u'david')
roger = model.Group.by_name(u'roger')
model.setup_default_user_roles(david, [russianfan])
model.setup_default_user_roles(roger, [russianfan])
model.add_user_to_role(visitor, model.Role.ADMIN, roger)
model.repo.commit_and_remove()
def create_arbitrary(cls,
package_dicts,
relationships=[],
extra_user_names=[],
extra_group_names=[],
admins=[]):
'''Creates packages and a few extra objects as well at the
same time if required.
@param package_dicts - a list of dictionaries with the package
properties.
Extra keys allowed:
"admins" - list of user names to make admin
for this package.
@param extra_group_names - a list of group names to create. No
properties get set though.
@param admins - a list of user names to make admins of all the
packages created.
'''
assert isinstance(relationships, (list, tuple))
assert isinstance(extra_user_names, (list, tuple))
assert isinstance(extra_group_names, (list, tuple))
model.Session.remove()
new_user_names = extra_user_names
new_group_names = set()
new_groups = {}
admins_list = defaultdict(list) # package_name: admin_names
if package_dicts:
if isinstance(package_dicts, dict):
package_dicts = [package_dicts]
for item in package_dicts:
rev = model.repo.new_revision()
rev.author = cls.author
rev.message = u'Creating test packages.'
pkg_dict = {}
for field in cls.pkg_core_fields:
if item.has_key(field):
pkg_dict[field] = unicode(item[field])
if model.Package.by_name(pkg_dict['name']):
log.warning('Cannot create package "%s" as it already exists.' % \
(pkg_dict['name']))
continue
pkg = model.Package(**pkg_dict)
model.Session.add(pkg)
for attr, val in item.items():
if isinstance(val, str):
val = unicode(val)
if attr == 'name':
continue
if attr in cls.pkg_core_fields:
pass
elif attr == 'download_url':
pkg.add_resource(unicode(val))
elif attr == 'resources':
assert isinstance(val, (list, tuple))
for res_dict in val:
non_extras = {}
for k, v in res_dict.items():
if k != 'extras':
if not isinstance(v, datetime.datetime):
v = unicode(v)
non_extras[str(k)] = v
extras = dict([
(str(k), unicode(v))
for k, v in res_dict.get('extras', {}).items()
])
pkg.add_resource(extras=extras, **non_extras)
elif attr == 'tags':
if isinstance(val, (str, unicode)):
tags = val.split()
elif isinstance(val, list):
tags = val
else:
raise NotImplementedError
for tag_name in tags:
tag_name = unicode(tag_name)
tag = model.Tag.by_name(tag_name)
if not tag:
tag = model.Tag(name=tag_name)
cls.tag_names.append(tag_name)
model.Session.add(tag)
pkg.add_tag(tag)
model.Session.flush()
elif attr == 'groups':
model.Session.flush()
if isinstance(val, (str, unicode)):
group_names = val.split()
elif isinstance(val, list):
group_names = val
else:
raise NotImplementedError
for group_name in group_names:
group = model.Group.by_name(unicode(group_name))
if not group:
if not group_name in new_groups:
group = model.Group(
name=unicode(group_name))
model.Session.add(group)
new_group_names.add(group_name)
new_groups[group_name] = group
else:
# If adding multiple packages with the same group name,
# model.Group.by_name will not find the group as the
# session has not yet been committed at this point.
# Fetch from the new_groups dict instead.
group = new_groups[group_name]
member = model.Member(group=group,
table_id=pkg.id,
table_name='package')
model.Session.add(member)
elif attr == 'license':
pkg.license_id = val
elif attr == 'license_id':
pkg.license_id = val
elif attr == 'extras':
pkg.extras = val
elif attr == 'admins':
assert isinstance(val, list)
admins_list[item['name']].extend(val)
for user_name in val:
if user_name not in new_user_names:
new_user_names.append(user_name)
else:
raise NotImplementedError(attr)
cls.pkg_names.append(item['name'])
model.setup_default_user_roles(pkg, admins=[])
for admin in admins:
admins_list[item['name']].append(admin)
model.repo.commit_and_remove()
needs_commit = False
rev = model.repo.new_revision()
for group_name in extra_group_names:
group = model.Group(name=unicode(group_name))
model.Session.add(group)
new_group_names.add(group_name)
needs_commit = True
if needs_commit:
model.repo.commit_and_remove()
needs_commit = False
# create users that have been identified as being needed
for user_name in new_user_names:
if not model.User.by_name(unicode(user_name)):
user = model.User(name=unicode(user_name))
model.Session.add(user)
cls.user_refs.append(user_name)
needs_commit = True
if needs_commit:
model.repo.commit_and_remove()
needs_commit = False
# setup authz for admins
for pkg_name, admins in admins_list.items():
pkg = model.Package.by_name(unicode(pkg_name))
admins_obj_list = []
for admin in admins:
if isinstance(admin, model.User):
admin_obj = admin
else:
admin_obj = model.User.by_name(unicode(admin))
assert admin_obj, admin
admins_obj_list.append(admin_obj)
model.setup_default_user_roles(pkg, admins_obj_list)
needs_commit = True
# setup authz for groups just created
for group_name in new_group_names:
group = model.Group.by_name(unicode(group_name))
model.setup_default_user_roles(group)
cls.group_names.add(group_name)
needs_commit = True
if needs_commit:
model.repo.commit_and_remove()
needs_commit = False
if relationships:
rev = model.repo.new_revision()
rev.author = cls.author
rev.message = u'Creating package relationships.'
def pkg(pkg_name):
return model.Package.by_name(unicode(pkg_name))
for subject_name, relationship, object_name in relationships:
pkg(subject_name).add_relationship(unicode(relationship),
pkg(object_name))
needs_commit = True
model.repo.commit_and_remove()
