def test_21_package_dictization_with_deleted_group(self):
"""
Ensure that the dictization does not return groups that the dataset has
been removed from.
"""
# Create a new dataset and 2 new groups
model.repo.new_revision()
pkg = model.Package(name='testing-deleted-groups')
group_1 = model.Group(name='test-group-1')
group_2 = model.Group(name='test-group-2')
model.Session.add(pkg)
model.Session.add(group_1)
model.Session.add(group_2)
model.Session.flush()
# Add the dataset to group_1, and signal that the dataset used
# to be a member of group_2 by setting its membership state to 'deleted'
membership_1 = model.Member(table_id=pkg.id,
table_name='package',
group=group_1,
group_id=group_1.id,
state='active')
membership_2 = model.Member(table_id=pkg.id,
table_name='package',
group=group_2,
group_id=group_2.id,
state='deleted')
model.Session.add(membership_1)
model.Session.add(membership_2)
model.repo.commit()
# Dictize the dataset
context = {"model": model, "session": model.Session}
result = package_dictize(pkg, context)
self.remove_changable_columns(result)
assert_not_in('test-group-2', [g['name'] for g in result['groups']])
assert_in('test-group-1', [g['name'] for g in result['groups']])
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.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_fork_within_a_transaction(self):
u"""
Test forking a worker horse within a database transaction.
The original instances should be unchanged but their session
must be closed.
"""
pkg_name = u"test-fork-within-a-transaction"
pkg = model.Package.get(pkg_name)
if not pkg:
pkg = model.Package(name=pkg_name)
pkg.title = u"foo"
pkg.save()
pkg.title = u"bar"
self.enqueue(database_job, [pkg.id, u"foo"])
jobs.Worker().work(burst=True)
assert pkg.title == u"bar" # Original instance is unchanged
# The original session has been closed, `pkg.Session` uses the new
# session in which `pkg` is not registered.
assert pkg not in pkg.Session
pkg = model.Package.get(pkg.id) # Get instance from new session
assert pkg.title == u"foofoo" # Worker only saw committed changes
def test_create(self):
# Demonstrate creating a package.
#
# In practice this is done by a combination of:
# * ckan.logic.action.create:package_create
# * ckan.lib.dictization.model_save.py:package_dict_save
# etc
pkg = model.Package(name=u"test-package")
pkg.notes = u"Some notes"
pkg.author = u"bob"
pkg.license_id = u"odc-by"
model.Session.add(pkg)
model.Session.commit()
model.Session.remove()
pkg = model.Package.by_name(u"test-package")
assert pkg.notes == u"Some notes"
assert pkg.author == u"bob"
assert pkg.license_id == u"odc-by"
assert pkg.license.title == u"Open Data Commons Attribution License"
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_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()
# 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 test_fork_within_a_transaction(self):
u'''
Test forking a worker horse within a database transaction.
The original instances should be unchanged but their session
must be closed.
'''
pkg_name = u'test-fork-within-a-transaction'
model.repo.new_revision()
pkg = model.Package.get(pkg_name)
if not pkg:
pkg = model.Package(name=pkg_name)
pkg.title = u'foo'
pkg.save()
pkg.title = u'bar'
self.enqueue(database_job, [pkg.id, u'foo'])
jobs.Worker().work(burst=True)
assert_equal(pkg.title, u'bar') # Original instance is unchanged
# The original session has been closed, `pkg.Session` uses the new
# session in which `pkg` is not registered.
assert_false(pkg in pkg.Session)
pkg = model.Package.get(pkg.id) # Get instance from new session
assert_equal(pkg.title, u'foofoo') # Worker only saw committed changes
def test_create_package_with_tags(self):
pkg = model.Package(name=factories.Dataset.stub().name)
# method 1
tag1 = model.Tag(name=factories.Tag.stub().name)
package_tag1 = model.PackageTag(package=pkg, tag=tag1)
pkg.package_tags[:] = [package_tag1]
# method 2
tag2 = model.Tag(name=factories.Tag.stub().name)
package_tag2 = model.PackageTag(package=pkg, tag=tag2)
pkg.add_tag(tag2)
# method 3
pkg.add_tag_by_name(u"energy")
model.Session.add_all([pkg, package_tag1, package_tag2])
model.Session.commit()
model.Session.remove()
pkg = model.Package.by_name(pkg.name)
assert set([tag.name for tag in pkg.get_tags()
]) == set([tag1.name, tag2.name, u"energy"])
def test_create_package_with_tags(self):
pkg = model.Package(name=u'test-package')
# method 1
tag1 = model.Tag(name=u'science')
package_tag1 = model.PackageTag(package=pkg, tag=tag1)
pkg.package_tag_all[:] = [package_tag1]
# method 2
tag2 = model.Tag(name=u'geology')
package_tag2 = model.PackageTag(package=pkg, tag=tag2)
pkg.add_tag(tag2)
# method 3
pkg.add_tag_by_name(u'energy')
model.Session.add_all([pkg, package_tag1, package_tag2])
model.Session.commit()
model.Session.remove()
pkg = model.Package.by_name(u'test-package')
assert_equal(set([tag.name for tag in pkg.get_tags()]),
set([u'science', u'geology', u'energy']))
def test_create_package_with_tags(self):
pkg = model.Package(name=u"test-package")
# method 1
tag1 = model.Tag(name=u"science")
package_tag1 = model.PackageTag(package=pkg, tag=tag1)
pkg.package_tag_all[:] = [package_tag1]
# method 2
tag2 = model.Tag(name=u"geology")
package_tag2 = model.PackageTag(package=pkg, tag=tag2)
pkg.add_tag(tag2)
# method 3
pkg.add_tag_by_name(u"energy")
model.Session.add_all([pkg, package_tag1, package_tag2])
model.Session.commit()
model.Session.remove()
pkg = model.Package.by_name(u"test-package")
assert set([tag.name for tag in pkg.get_tags()
]) == set([u"science", u"geology", u"energy"])
def setup_class(self):
model.Session.remove()
model.repo.init_db()
self.name = u'revisiontest'
# create pkg
self.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()
self.pkg1 = model.Package(name=self.name)
model.Session.add(self.pkg1)
self.pkg1.notes = self.notes[0]
self.pkg1.extras['mykey'] = self.notes[0]
model.repo.commit_and_remove()
# edit pkg
for i in range(5)[1:]:
rev = model.repo.new_revision()
pkg1 = model.Package.by_name(self.name)
pkg1.notes = self.notes[i]
pkg1.extras['mykey'] = self.notes[i]
model.repo.commit_and_remove()
self.pkg1 = model.Package.by_name(self.name)
def test_create(self):
# Demonstrate creating a package.
#
# In practice this is done by a combination of:
# * ckan.logic.action.create:package_create
# * ckan.lib.dictization.model_save.py:package_dict_save
# etc
pkg = model.Package(name=u'test-package')
pkg.notes = u'Some notes'
pkg.author = u'bob'
pkg.license_id = u'odc-by'
model.Session.add(pkg)
model.Session.commit()
model.Session.remove()
pkg = model.Package.by_name(u'test-package')
assert_equal(pkg.notes, u'Some notes')
assert_equal(pkg.author, u'bob')
assert_equal(pkg.license_id, u'odc-by')
assert_equal(pkg.license.title,
u'Open Data Commons Attribution License')
def roles_all_list(context, data_dict):
'''
Returns the roles of the given user
:returns: roles
:rtype: dictionary
'''
if (check_access('roles_all_list', context, data_dict) == True):
user_name = data_dict.get('user_name')
log.info('Looking up roles for user %r ...', user_name)
try:
all_roles = []
users = model.User.all()
for user in users:
user_roles = {'name': user.name}
roles = {'System': [], 'Group': [], 'Package': []}
for role in [u'admin', u'editor', u'reader']:
if (authz.user_has_role(user, role, model.System())):
roles['System'].append(role)
if (authz.user_has_role(user, role, model.Package())):
roles['Package'].append(role)
if (authz.user_has_role(user, role, model.Group())):
roles['Group'].append(role)
user_roles['roles'] = roles
all_roles.append(user_roles)
result = all_roles
return {'success': True, 'result': result}
except:
return {'success': False, 'msg': traceback.print_exc()}
else:
return {'success': False, 'msg': 'authentication failed'}
def setup_class(self):
# for the authorization editing tests we set up test data so:
# three users, sysadmin , administrator, and another
# one group, one package
# and administrator is admin on all three
model.repo.init_db()
model.repo.new_revision()
self.sysadmin = 'sysadmin'
sysadmin_user = model.User(name=unicode(self.sysadmin))
self.admin = 'administrator'
admin_user = model.User(name=unicode(self.admin))
self.another = 'another'
another_user = model.User(name=unicode(self.another))
self.group = 'group'
group = model.Group(name=unicode(self.group))
for obj in sysadmin_user, admin_user, another_user, group:
model.Session.add(obj)
model.add_user_to_role(sysadmin_user, model.Role.ADMIN, model.System())
model.repo.commit_and_remove()
model.repo.new_revision()
self.pkg = u'dataset'
pkg = model.Package(name=self.pkg)
model.Session.add(pkg)
admin_user = model.User.by_name(unicode(self.admin))
assert admin_user
# setup all three authorization objects to have logged in and visitor as editors, and the admin as admin
model.setup_user_roles(pkg, ['editor'], ['editor'], [admin_user])
model.setup_user_roles(group, ['editor'], ['editor'], [admin_user])
model.repo.commit_and_remove()
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.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
]
with cls.app.flask_app.test_request_context():
cls.offset = url_for(controller='package',
action='history',
id=cls.pkg1.name)
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://datahub.io'
# 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://datahub.io/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://datahub.io/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_all.append(pr1)
pkg1.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://datahub.io',
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()
def create_arbitrary(cls,
package_dicts,
relationships=[],
extra_user_names=[],
extra_group_names=[]):
'''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:
@param extra_group_names - a list of group names to create. No
properties get set though.
'''
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 = {}
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 = {
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]
capacity = 'organization' if group.is_organization\
else 'public'
member = model.Member(group=group,
table_id=pkg.id,
table_name='package',
capacity=capacity)
model.Session.add(member)
if group.is_organization:
pkg.owner_org = group.id
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 0, 'Deprecated param "admins"'
else:
raise NotImplementedError(attr)
cls.pkg_names.append(item['name'])
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 groups just created
for group_name in new_group_names:
group = model.Group.by_name(unicode(group_name))
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_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))
import ckan.model as model
model.Session.remove()
new_user_names = extra_user_names
new_group_names = set()
new_groups = {}
rev = model.repo.new_revision()
rev.author = cls.author
rev.message = u'Creating test packages.'
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:
pkg_dict = {}
for field in cls.pkg_core_fields:
if item.has_key(field):
pkg_dict[field] = unicode(item[field])
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 test_sorting(self):
model.repo.rebuild_db()
testsysadmin = model.User(name=u'testsysadmin')
testsysadmin.sysadmin = True
model.Session.add(testsysadmin)
pkg1 = model.Package(name="pkg1")
pkg2 = model.Package(name="pkg2")
model.Session.add(pkg1)
model.Session.add(pkg2)
CreateTestData.create_groups([{
'name': "alpha",
'title': "Alpha",
'packages': []
}, {
'name': "beta",
'title': "Beta",
'packages': ["pkg1", "pkg2"]
}, {
'name': "delta",
'title': 'Delta',
'packages': ["pkg1"]
}, {
'name': "gamma",
'title': "Gamma",
'packages': []
}],
admin_user_name='testsysadmin')
context = {
'model': model,
'session': model.Session,
'user': '******',
'for_view': True,
'with_private': False
}
data_dict = {'all_fields': True}
results = get_action('group_list')(context, data_dict)
assert results[0]['name'] == u'alpha', results[0]['name']
assert results[-1]['name'] == u'gamma', results[-1]['name']
# Test title forward
data_dict = {'all_fields': True, 'sort': 'title asc'}
results = get_action('group_list')(context, data_dict)
assert results[0]['name'] == u'alpha', results[0]['name']
assert results[-1]['name'] == u'gamma', results[-1]['name']
# Test title reverse
data_dict = {'all_fields': True, 'sort': 'title desc'}
results = get_action('group_list')(context, data_dict)
assert results[0]['name'] == u'gamma', results[0]['name']
assert results[-1]['name'] == u'alpha', results[-1]['name']
# Test name reverse
data_dict = {'all_fields': True, 'sort': 'name desc'}
results = get_action('group_list')(context, data_dict)
assert results[0]['name'] == u'gamma', results[0]['name']
assert results[-1]['name'] == u'alpha', results[-1]['name']
# Test packages reversed
data_dict = {'all_fields': True, 'sort': 'package_count desc'}
results = get_action('group_list')(context, data_dict)
assert results[0]['name'] == u'beta', results[0]['name']
assert results[1]['name'] == u'delta', results[1]['name']
# Test packages forward
data_dict = {'all_fields': True, 'sort': 'package_count asc'}
results = get_action('group_list')(context, data_dict)
assert results[-2]['name'] == u'delta', results[-2]['name']
assert results[-1]['name'] == u'beta', results[-1]['name']
# Default ordering for packages
data_dict = {'all_fields': True, 'sort': 'package_count'}
results = get_action('group_list')(context, data_dict)
assert results[0]['name'] == u'beta', results[0]['name']
assert results[1]['name'] == u'delta', results[1]['name']
def test_sorting():
testsysadmin = factories.Sysadmin(name=u"testsysadmin")
pkg1 = model.Package(name="pkg1")
pkg2 = model.Package(name="pkg2")
model.Session.add(pkg1)
model.Session.add(pkg2)
CreateTestData.create_groups(
[
{
"name": "alpha",
"title": "Alpha",
"packages": []
},
{
"name": "beta",
"title": "Beta",
"packages": ["pkg1", "pkg2"]
},
{
"name": "delta",
"title": "Delta",
"packages": ["pkg1"]
},
{
"name": "gamma",
"title": "Gamma",
"packages": []
},
],
admin_user_name="testsysadmin",
)
context = {
"model": model,
"session": model.Session,
"user": "******",
"for_view": True,
"with_private": False,
}
data_dict = {"all_fields": True}
results = get_action("group_list")(context, data_dict)
assert results[0]["name"] == u"alpha", results[0]["name"]
assert results[-1]["name"] == u"gamma", results[-1]["name"]
# Test title forward
data_dict = {"all_fields": True, "sort": "title asc"}
results = get_action("group_list")(context, data_dict)
assert results[0]["name"] == u"alpha", results[0]["name"]
assert results[-1]["name"] == u"gamma", results[-1]["name"]
# Test title reverse
data_dict = {"all_fields": True, "sort": "title desc"}
results = get_action("group_list")(context, data_dict)
assert results[0]["name"] == u"gamma", results[0]["name"]
assert results[-1]["name"] == u"alpha", results[-1]["name"]
# Test name reverse
data_dict = {"all_fields": True, "sort": "name desc"}
results = get_action("group_list")(context, data_dict)
assert results[0]["name"] == u"gamma", results[0]["name"]
assert results[-1]["name"] == u"alpha", results[-1]["name"]
# Test packages reversed
data_dict = {"all_fields": True, "sort": "package_count desc"}
results = get_action("group_list")(context, data_dict)
assert results[0]["name"] == u"beta", results[0]["name"]
assert results[1]["name"] == u"delta", results[1]["name"]
# Test packages forward
data_dict = {"all_fields": True, "sort": "package_count asc"}
results = get_action("group_list")(context, data_dict)
assert results[-2]["name"] == u"delta", results[-2]["name"]
assert results[-1]["name"] == u"beta", results[-1]["name"]
# Default ordering for packages
data_dict = {"all_fields": True, "sort": "package_count"}
results = get_action("group_list")(context, data_dict)
assert results[0]["name"] == u"beta", results[0]["name"]
assert results[1]["name"] == u"delta", results[1]["name"]
def create(cls, auth_profile="", package_type=None):
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
'''
if auth_profile == "publisher":
publisher_group = model.Group(name=u"publisher_group", type="publisher")
cls.pkg_names = [u'annakarenina', u'warandpeace']
pkg1 = model.Package(name=cls.pkg_names[0], type=package_type)
if auth_profile == "publisher":
pkg1.group = publisher_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.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], type=package_type)
tag1 = model.Tag(name=u'russian')
tag2 = model.Tag(name=u'tolstoy')
if auth_profile == "publisher":
pkg2.group = publisher_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
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 test_metadata_created_and_modified(self):
# create a new package
name = "test_metadata"
rev = model.repo.new_revision()
package = model.Package(name=name)
model.Session.add(package)
model.Session.flush()
revision_id = model.Session().revision.id
created_timestamp = model.Session().revision.timestamp
model.repo.commit_and_remove()
package = model.Package.by_name(name)
assert package.metadata_created == created_timestamp,\
(package.metadata_created, created_timestamp)
assert package.metadata_modified == created_timestamp,\
(package.metadata_modified, created_timestamp)
# update the package
rev = model.repo.new_revision()
package = model.Package.by_name(name)
package.title = "test_metadata_new_title"
modified_timestamp = model.Session().revision.timestamp
model.repo.commit_and_remove()
package = model.Package.by_name(name)
assert package.metadata_created == created_timestamp
assert package.metadata_modified == modified_timestamp
last_modified_timestamp = modified_timestamp
# update a package's tag
rev = model.repo.new_revision()
package = model.Package.by_name(name)
package.add_tag_by_name('new-tag')
modified_timestamp = model.Session().revision.timestamp
assert modified_timestamp != last_modified_timestamp
model.repo.commit_and_remove()
package = model.Package.by_name(name)
assert package.metadata_created == created_timestamp
assert package.metadata_modified == modified_timestamp
last_modified_timestamp = modified_timestamp
# update a package's extra
rev = model.repo.new_revision()
package = model.Package.by_name(name)
package.extras['new-key'] = 'value'
modified_timestamp = model.Session().revision.timestamp
assert modified_timestamp != last_modified_timestamp
model.repo.commit_and_remove()
package = model.Package.by_name(name)
assert package.metadata_created == created_timestamp
assert package.metadata_modified == modified_timestamp
last_modified_timestamp = modified_timestamp
# update a package's relationship
rev = model.repo.new_revision()
package = model.Package.by_name(name)
anna = model.Package.by_name(u'annakarenina')
package.add_relationship(u'child_of', anna)
modified_timestamp = model.Session().revision.timestamp
assert modified_timestamp != last_modified_timestamp
model.repo.commit_and_remove()
package = model.Package.by_name(name)
assert package.metadata_created == created_timestamp
assert package.metadata_modified == modified_timestamp
last_modified_timestamp = modified_timestamp
# update a package's group - NB no change this time
rev = model.repo.new_revision()
group = model.Group.by_name('roger')
group.add_package_by_name(name)
modified_timestamp = model.Session().revision.timestamp
assert modified_timestamp != last_modified_timestamp
model.repo.commit_and_remove()
package = model.Package.by_name(name)
assert package.metadata_created == created_timestamp
assert package.metadata_modified == last_modified_timestamp # no change
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_test_data(cls):
# Entities (Packages/Groups) are named after what roles (permissions)
# are assigned to them:
# First letter is the role for logged in users
# Second letter is the role for visitors
# Where:
# r = Allowed to read
# w = Allowed to read/write
# x = Not allowed either
model.repo.init_db()
rev = model.repo.new_revision()
cls.roles = ('xx', 'rx', 'wx', 'rr', 'wr', 'ww', 'deleted')
tag = model.Tag("test")
model.Session.add(tag)
for mode in cls.roles:
pkg = model.Package(name=unicode(mode))
model.Session.add(pkg)
pkg.add_tag(tag)
model.Session.add(model.Group(name=unicode(mode)))
entities_to_test_deleting = []
for interface in cls.INTERFACES:
for action in ('purge', 'delete'):
for user in ('visitor', 'user', 'admin', 'mrloggedin',
'testsysadmin', 'pkggroupadmin'):
for entity_type in cls.DEFAULT_ENTITY_TYPES:
entity_class = cls.ENTITY_CLASS_MAP[entity_type]
entity_name = u'%s_%s_%s' % (action, user, interface)
model.Session.add(entity_class(name=entity_name))
entities_to_test_deleting.append(
(entity_name, entity_class))
model.Session.add(model.User(name=u'testsysadmin'))
model.Session.add(model.User(name=u'pkggroupadmin'))
model.Session.add(model.User(name=u'pkgeditor'))
model.Session.add(model.User(name=u'pkgreader'))
model.Session.add(model.User(name=u'mrloggedin'))
model.Session.add(model.User(name=u'pkgadminfriend'))
model.Session.add(model.User(name=u'groupadmin'))
model.Session.add(model.User(name=u'groupeditor'))
model.Session.add(model.User(name=u'groupreader'))
visitor_name = '123.12.12.123'
model.repo.commit_and_remove()
rev = model.repo.new_revision()
model.Package.by_name(u'ww').add_relationship(
u'depends_on', model.Package.by_name(u'xx'))
model.Package.by_name(u'ww').add_relationship(
u'links_to', model.Package.by_name(u'wr'))
model.repo.commit_and_remove()
testsysadmin = model.User.by_name(u'testsysadmin')
pkggroupadmin = model.User.by_name(u'pkggroupadmin')
pkgeditor = model.User.by_name(u'pkgeditor')
pkgreader = model.User.by_name(u'pkgreader')
groupadmin = model.User.by_name(u'groupadmin')
groupeditor = model.User.by_name(u'groupeditor')
groupreader = model.User.by_name(u'groupreader')
mrloggedin = model.User.by_name(name=u'mrloggedin')
visitor = model.User.by_name(name=model.PSEUDO_USER__VISITOR)
for mode in cls.roles:
pkg = model.Package.by_name(unicode(mode))
model.add_user_to_role(pkggroupadmin, model.Role.ADMIN, pkg)
model.add_user_to_role(pkgeditor, model.Role.EDITOR, pkg)
model.add_user_to_role(pkgreader, model.Role.READER, pkg)
group = model.Group.by_name(unicode(mode))
group.packages = model.Session.query(model.Package).all()
model.add_user_to_role(pkggroupadmin, model.Role.ADMIN, group)
model.add_user_to_role(groupadmin, model.Role.ADMIN, group)
model.add_user_to_role(groupeditor, model.Role.EDITOR, group)
model.add_user_to_role(groupreader, model.Role.READER, group)
if mode == u'deleted':
rev = model.repo.new_revision()
pkg = model.Package.by_name(unicode(mode))
pkg.state = model.State.DELETED
group = model.Package.by_name(unicode(mode))
group.state = model.State.DELETED
model.repo.commit_and_remove()
else:
if mode[0] == u'r':
model.add_user_to_role(mrloggedin, model.Role.READER, pkg)
model.add_user_to_role(mrloggedin, model.Role.READER,
group)
if mode[0] == u'w':
model.add_user_to_role(mrloggedin, model.Role.EDITOR, pkg)
model.add_user_to_role(mrloggedin, model.Role.EDITOR,
group)
if mode[1] == u'r':
model.add_user_to_role(visitor, model.Role.READER, pkg)
model.add_user_to_role(visitor, model.Role.READER, group)
if mode[1] == u'w':
model.add_user_to_role(visitor, model.Role.EDITOR, pkg)
model.add_user_to_role(visitor, model.Role.EDITOR, group)
model.add_user_to_role(testsysadmin, model.Role.ADMIN, model.System())
for entity_name, entity_class in entities_to_test_deleting:
entity = entity_class.by_name(entity_name)
model.add_user_to_role(visitor, model.Role.EDITOR, entity)
model.add_user_to_role(mrloggedin, model.Role.EDITOR, entity)
model.add_user_to_role(visitor, model.Role.READER, entity)
model.add_user_to_role(mrloggedin, model.Role.READER, entity)
model.add_user_to_role(pkggroupadmin, model.Role.ADMIN, entity)
model.repo.commit_and_remove()
assert model.Package.by_name(u'deleted').state == model.State.DELETED
cls.testsysadmin = model.User.by_name(u'testsysadmin')
cls.pkggroupadmin = model.User.by_name(u'pkggroupadmin')
cls.pkgadminfriend = model.User.by_name(u'pkgadminfriend')
cls.pkgeditor = model.User.by_name(u'pkgeditor')
cls.pkgreader = model.User.by_name(u'pkgreader')
cls.groupadmin = model.User.by_name(u'groupadmin')
cls.groupeditor = model.User.by_name(u'groupeditor')
cls.groupreader = model.User.by_name(u'groupreader')
cls.mrloggedin = model.User.by_name(name=u'mrloggedin')
cls.visitor = model.User.by_name(name=model.PSEUDO_USER__VISITOR)
def setup_class(self):
CreateTestData.create()
model.Session.remove()
self.name = u'difftest'
# create pkg - PackageRevision
rev = model.repo.new_revision()
self.pkg1 = model.Package(name=self.name)
model.Session.add(self.pkg1)
self.pkg1.version = u'First version'
model.repo.commit_and_remove()
# edit pkg - PackageRevision
rev = model.repo.new_revision()
pkg1 = model.Package.by_name(self.name)
pkg1.notes = u'New notes'
rev.message = u'Added notes'
model.repo.commit_and_remove()
# edit pkg - PackageExtraRevision
rev = model.repo.new_revision()
pkg1 = model.Package.by_name(self.name)
pkg1.extras = {u'a':u'b', u'c':u'd'}
rev.message = u'Added extras'
model.repo.commit_and_remove()
# edit pkg - PackageTagRevision
rev = model.repo.new_revision()
pkg1 = model.Package.by_name(self.name)
pkg1.add_tag_by_name(u'geo')
pkg1.add_tag_by_name(u'scientific')
rev.message = u'Added tags'
model.repo.commit_and_remove()
# edit pkg - ResourceRevision
rev = model.repo.new_revision()
pkg1 = model.Package.by_name(self.name)
pkg1.resources.append(model.Resource(url=u'http://url1.com',
format=u'xls',
description=u'It is.',
hash=u'abc123'))
rev.message = u'Added resource'
model.repo.commit_and_remove()
# edit pkg - ResourceRevision
rev = model.repo.new_revision()
pkg1 = model.Package.by_name(self.name)
pkg1.resources[0].url = u'http://url1.com/edited'
pkg1.resources.append(model.Resource(url=u'http://url2.com'))
rev.message = u'Added resource'
model.repo.commit_and_remove()
# edit pkg - PackageRevision
rev = model.repo.new_revision()
pkg1 = model.Package.by_name(self.name)
pkg1.notes = u'Changed notes'
rev.message = u'Changed notes'
model.repo.commit_and_remove()
self.pkg1 = model.Package.by_name(self.name)
self.res1 = model.Session.query(model.Resource).filter_by(url=u'http://url1.com/edited').one()
self.res2 = model.Session.query(model.Resource).filter_by(url=u'http://url2.com').one()
assert self.pkg1
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
