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