def package_dictize(pkg, context):
model = context['model']
#package
package_rev = model.package_revision_table
q = select([package_rev]).where(package_rev.c.id == pkg.id)
result = _execute_with_revision(q, package_rev, context).first()
if not result:
raise NotFound
result_dict = table_dictize(result, context)
#resources
res_rev = model.resource_revision_table
resource_group = model.resource_group_table
q = select([res_rev], from_obj = res_rev.join(resource_group,
resource_group.c.id == res_rev.c.resource_group_id))
q = q.where(resource_group.c.package_id == pkg.id)
result = _execute_with_revision(q, res_rev, context)
result_dict["resources"] = resource_list_dictize(result, context)
#tags
tag_rev = model.package_tag_revision_table
tag = model.tag_table
q = select([tag, tag_rev.c.state, tag_rev.c.revision_timestamp],
from_obj=tag_rev.join(tag, tag.c.id == tag_rev.c.tag_id)
).where(tag_rev.c.package_id == pkg.id)
result = _execute_with_revision(q, tag_rev, context)
result_dict["tags"] = obj_list_dictize(result, context, lambda x: x["name"])
#extras
extra_rev = model.extra_revision_table
q = select([extra_rev]).where(extra_rev.c.package_id == pkg.id)
result = _execute_with_revision(q, extra_rev, context)
result_dict["extras"] = extras_list_dictize(result, context)
#groups
group_rev = model.package_group_revision_table
group = model.group_table
q = select([group],
from_obj=group_rev.join(group, group.c.id == group_rev.c.group_id)
).where(group_rev.c.package_id == pkg.id)
result = _execute_with_revision(q, group_rev, context)
result_dict["groups"] = obj_list_dictize(result, context)
#relations
rel_rev = model.package_relationship_revision_table
q = select([rel_rev]).where(rel_rev.c.subject_package_id == pkg.id)
result = _execute_with_revision(q, rel_rev, context)
result_dict["relationships_as_subject"] = obj_list_dictize(result, context)
q = select([rel_rev]).where(rel_rev.c.object_package_id == pkg.id)
result = _execute_with_revision(q, rel_rev, context)
result_dict["relationships_as_object"] = obj_list_dictize(result, context)
#isopen
# Get an actual Package object, not a PackageRevision
pkg_object = model.Package.get(pkg.id)
result_dict['isopen'] = pkg_object.isopen if isinstance(pkg_object.isopen,bool) else pkg_object.isopen()
return result_dict
def group_dictize(group, context):
model = context['model']
result_dict = d.table_dictize(group, context)
result_dict['display_name'] = group.display_name
result_dict['extras'] = extras_dict_dictize(
group._extras, context)
context['with_capacity'] = True
result_dict['packages'] = d.obj_list_dictize(
_get_members(context, group, 'packages'),
context)
result_dict['tags'] = tag_list_dictize(
_get_members(context, group, 'tags'),
context)
result_dict['groups'] = group_list_dictize(
_get_members(context, group, 'groups'),
context)
result_dict['users'] = user_list_dictize(
_get_members(context, group, 'users'),
context)
context['with_capacity'] = False
if context.get('for_view'):
for item in plugins.PluginImplementations(plugins.IGroupController):
result_dict = item.before_view(result_dict)
return result_dict
def tag_dictize(tag, context):
result_dict = table_dictize(tag, context)
result_dict["packages"] = obj_list_dictize(tag.packages, context)
return result_dict
def group_dictize(group, context):
model = context["model"]
result_dict = table_dictize(group, context)
result_dict["display_name"] = group.display_name
result_dict["extras"] = extras_dict_dictize(group._extras, context)
context["with_capacity"] = True
result_dict["packages"] = obj_list_dictize(_get_members(context, group, "packages"), context)
result_dict["tags"] = tag_list_dictize(_get_members(context, group, "tags"), context)
result_dict["groups"] = group_list_dictize(_get_members(context, group, "groups"), context)
result_dict["users"] = user_list_dictize(_get_members(context, group, "users"), context)
context["with_capacity"] = False
if context.get("for_view"):
for item in PluginImplementations(IGroupController):
result_dict = item.before_view(result_dict)
return result_dict
def group_dictize(group, context):
model = context['model']
result_dict = table_dictize(group, context)
result_dict['display_name'] = group.display_name
result_dict['extras'] = extras_dict_dictize(
group._extras, context)
context['with_capacity'] = True
result_dict['packages'] = obj_list_dictize(
_get_members(context, group, 'packages'),
context)
result_dict['tags'] = tag_list_dictize(
_get_members(context, group, 'tags'),
context)
result_dict['groups'] = group_list_dictize(
_get_members(context, group, 'groups'),
context)
result_dict['users'] = user_list_dictize(
_get_members(context, group, 'users'),
context)
context['with_capacity'] = False
return result_dict
def after_show(self, context, pkg_dict):
try:
cookies = tk.request.cookies
except TypeError:
# TypeError: No object (name: request) has been registered for this thread.
cookies = None
if cookies is not None:
territory_json_str = cookies.get('territory')
if territory_json_str:
c = tk.c
try:
c.territory = json.loads(territory_json_str)
except ValueError:
pass
else:
full_name = c.territory.get('full_name')
if full_name is not None:
c.territory['full_name_slug'] = strings.slugify(full_name)
# Add supplier to pkg_dict
from ckan.lib.dictization import model_dictize
supplier_id = pkg_dict.get('supplier_id')
if supplier_id is not None:
# Code derivated from model_dictize.package_dictize.
model = context['model']
group_rev = model.group_revision_table
q = select([group_rev]) \
.where(group_rev.c.id == supplier_id) \
.where(group_rev.c.state == 'active')
result = model_dictize._execute_with_revision(q, group_rev, context)
organizations = dictization.obj_list_dictize(result, context)
pkg_dict['supplier'] = organizations[0] if organizations else None
def group_dictize(group, context):
model = context['model']
result_dict = d.table_dictize(group, context)
result_dict['display_name'] = group.display_name
result_dict['extras'] = extras_dict_dictize(
group._extras, context)
context['with_capacity'] = True
result_dict['packages'] = d.obj_list_dictize(
_get_members(context, group, 'packages'),
context)
query = search.PackageSearchQuery()
if group.is_organization:
q = {'q': 'owner_org:"%s" +capacity:public' % group.id, 'rows': 1}
else:
q = {'q': 'groups:"%s" +capacity:public' % group.name, 'rows': 1}
package_count = query.run(q)['count']
result_dict['package_count'] = package_count
# if group.is_organization:
# q = {'q': 'owner_org:"%s" +capacity:public' % group.id, 'rows': package_count}
# packages = query.run(q)['results']
## log.error(str(packages))
# result_dict['packages'] = packages
result_dict['tags'] = tag_list_dictize(
_get_members(context, group, 'tags'),
context)
result_dict['groups'] = group_list_dictize(
_get_members(context, group, 'groups'),
context)
if context.get('for_view'):
context['user'] = '******'
result_dict['users'] = user_list_dictize(
_get_members(context, group, 'users'),
context)
context['with_capacity'] = False
if context.get('for_view'):
if result_dict['is_organization']:
plugin = plugins.IOrganizationController
else:
plugin = plugins.IGroupController
for item in plugins.PluginImplementations(plugin):
result_dict = item.before_view(result_dict)
return result_dict
def group_dictize(group, context):
model = context['model']
result_dict = d.table_dictize(group, context)
result_dict['display_name'] = group.display_name
result_dict['extras'] = extras_dict_dictize(
group._extras, context)
context['with_capacity'] = True
result_dict['packages'] = d.obj_list_dictize(
_get_members(context, group, 'packages'),
context)
query = search.PackageSearchQuery()
if group.is_organization:
q = {'q': 'owner_org:"%s" +capacity:public' % group.id, 'rows': 1}
else:
q = {'q': 'groups:"%s" +capacity:public' % group.name, 'rows': 1}
result_dict['package_count'] = query.run(q)['count']
result_dict['tags'] = tag_list_dictize(
_get_members(context, group, 'tags'),
context)
result_dict['groups'] = group_list_dictize(
_get_members(context, group, 'groups'),
context)
result_dict['users'] = user_list_dictize(
_get_members(context, group, 'users'),
context)
context['with_capacity'] = False
if context.get('for_view'):
if result_dict['is_organization']:
plugin = plugins.IOrganizationController
else:
plugin = plugins.IGroupController
for item in plugins.PluginImplementations(plugin):
result_dict = item.before_view(result_dict)
image_url = result_dict.get('image_url')
result_dict['image_display_url'] = image_url
if image_url and not image_url.startswith('http'):
#munge here should not have an effect only doing it incase
#of potential vulnerability of dodgy api input
image_url = munge.munge_filename(image_url)
result_dict['image_display_url'] = h.url_for_static(
'uploads/group/%s' % result_dict.get('image_url'),
qualified = True
)
return result_dict
def group_dictize(group, context):
result_dict = table_dictize(group, context)
result_dict["extras"] = extras_dict_dictize(
group._extras, context)
result_dict["packages"] = obj_list_dictize(
group.packages, context)
return result_dict
def group_dictize(group, context):
result_dict = table_dictize(group, context)
result_dict['display_name'] = group.display_name
result_dict['extras'] = extras_dict_dictize(
group._extras, context)
result_dict['packages'] = obj_list_dictize(
group.packages, context)
return result_dict
def tag_dictize(tag, context):
result_dict = d.table_dictize(tag, context)
result_dict["packages"] = d.obj_list_dictize(tag.packages, context)
# Add display_names to tags. At first a tag's display_name is just the
# same as its name, but the display_name might get changed later (e.g.
# translated into another language by the multilingual extension).
assert not result_dict.has_key('display_name')
result_dict['display_name'] = result_dict['name']
if context.get('for_view'):
for item in plugins.PluginImplementations(
plugins.ITagController):
result_dict = item.before_view(result_dict)
return result_dict
def dump_groups(date, options):
from ckan import model
# column headings
header = ['name', 'id', 'title']
headings_all = set(header)
headings_main = set()
headings_extra = set()
# get the groups
group_rev_table = model.group_revision_table
q = select([group_rev_table])
if options.organization:
q = q.where(group_rev_table.c.name==options.organization)
context = {'model': model, 'session': model.Session,
'revision_date': date}
result = model_dictize._execute_with_revision(q, group_rev_table, context)
groups = obj_list_dictize(result, context)
# just double check there are no deleted ones in the list
for group in groups:
assert group['state'] == 'active'
print '%i groups' % len(groups)
for group in groups:
# get the group extras
group_extra_rev_table = model.group_extra.group_extra_revision_table
q = select([group_extra_rev_table]) \
.where(group_extra_rev_table.c.group_id == group['id'])
result = model_dictize._execute_with_revision(q, group_extra_rev_table,
context)
extras = result.fetchall()
for extra in extras:
if extra['state'] == 'active':
group['extra-%s' % extra['key']] = extra['value']
#group['extras'] = model_dictize.extras_list_dictize(result, context)
for delete_property in ['revision_timestamp', 'revision_id']:
del group[delete_property]
# get the parent group
member_rev_table = model.member_revision_table
q = select([member_rev_table]) \
.where(member_rev_table.c.group_id == group['id']) \
.where(member_rev_table.c.table_name == 'group')
result = model_dictize._execute_with_revision(q, member_rev_table,
context)
parents = result.fetchall()
for parent in parents:
if parent['state'] == 'active':
parent_group = model.Group.get(parent['table_id'])
group['parent'] = parent_group.name
# member revisions seem to miss a good number, so default to the current parent
if 'parent' not in group:
members = model.Session.query(model.Member) \
.filter_by(group_id=group['id']) \
.filter_by(table_name='group') \
.all()
if members:
parent_group = model.Group.get(members[0].table_id)
if parent_group:
group['parent'] = parent_group.name
# column headings
for key in group.keys():
if key not in headings_all:
if key.startswith('extra-'):
headings_extra.add(key)
else:
headings_main.add(key)
headings_all.add(key)
groups.sort(key=lambda g: g['name'])
header += sorted(headings_main) + sorted(headings_extra)
# write CSV
csv_filepath = date.strftime(options.filename or 'groups-%Y-%m-%d.csv')
#csv_filepath = options.filename or 'groups.csv'
print 'Writing %s' % csv_filepath
with open(csv_filepath, 'w') as f:
w = UnicodeDictWriter(f, header, encoding='utf8')
w.writerow(dict(zip(header, header)))
w.writerows(groups)
def package_dictize(pkg, context):
'''
Given a Package object, returns an equivalent dictionary.
Normally this is the current revision (most recent moderated version),
but you can provide revision_id, revision_date or pending in the
context and it will filter to an earlier time or the latest unmoderated
object revision.
May raise NotFound. TODO: understand what the specific set of
circumstances are that cause this.
'''
model = context['model']
#package
package_rev = model.package_revision_table
q = select([package_rev]).where(package_rev.c.id == pkg.id)
result = _execute_with_revision(q, package_rev, context).first()
if not result:
raise NotFound
result_dict = table_dictize(result, context)
#resources
res_rev = model.resource_revision_table
resource_group = model.resource_group_table
q = select([res_rev], from_obj = res_rev.join(resource_group,
resource_group.c.id == res_rev.c.resource_group_id))
q = q.where(resource_group.c.package_id == pkg.id)
result = _execute_with_revision(q, res_rev, context)
result_dict["resources"] = resource_list_dictize(result, context)
#tags
tag_rev = model.package_tag_revision_table
tag = model.tag_table
q = select([tag, tag_rev.c.state, tag_rev.c.revision_timestamp],
from_obj=tag_rev.join(tag, tag.c.id == tag_rev.c.tag_id)
).where(tag_rev.c.package_id == pkg.id)
result = _execute_with_revision(q, tag_rev, context)
result_dict["tags"] = obj_list_dictize(result, context, lambda x: x["name"])
#extras
extra_rev = model.extra_revision_table
q = select([extra_rev]).where(extra_rev.c.package_id == pkg.id)
result = _execute_with_revision(q, extra_rev, context)
result_dict["extras"] = extras_list_dictize(result, context)
#groups
member_rev = model.member_revision_table
group = model.group_table
q = select([group],
from_obj=member_rev.join(group, group.c.id == member_rev.c.group_id)
).where(member_rev.c.table_id == pkg.id)
result = _execute_with_revision(q, member_rev, context)
result_dict["groups"] = obj_list_dictize(result, context)
#relations
rel_rev = model.package_relationship_revision_table
q = select([rel_rev]).where(rel_rev.c.subject_package_id == pkg.id)
result = _execute_with_revision(q, rel_rev, context)
result_dict["relationships_as_subject"] = obj_list_dictize(result, context)
q = select([rel_rev]).where(rel_rev.c.object_package_id == pkg.id)
result = _execute_with_revision(q, rel_rev, context)
result_dict["relationships_as_object"] = obj_list_dictize(result, context)
# Extra properties from the domain object
# We need an actual Package object for this, not a PackageRevision
if isinstance(pkg,PackageRevision):
pkg = model.Package.get(pkg.id)
# isopen
result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen,bool) else pkg.isopen()
# creation and modification date
result_dict['metadata_modified'] = pkg.metadata_modified.isoformat() \
if pkg.metadata_modified else None
result_dict['metadata_created'] = pkg.metadata_created.isoformat() \
if pkg.metadata_created else None
return result_dict
def package_dictize(pkg, context):
'''
Given a Package object, returns an equivalent dictionary.
Normally this is the current revision (most recent moderated version),
but you can provide revision_id, revision_date or pending in the
context and it will filter to an earlier time or the latest unmoderated
object revision.
May raise NotFound. TODO: understand what the specific set of
circumstances are that cause this.
'''
model = context['model']
#package
package_rev = model.package_revision_table
q = select([package_rev]).where(package_rev.c.id == pkg.id)
result = _execute_with_revision(q, package_rev, context).first()
if not result:
raise logic.NotFound
result_dict = d.table_dictize(result, context)
#strip whitespace from title
if result_dict.get('title'):
result_dict['title'] = result_dict['title'].strip()
#resources
res_rev = model.resource_revision_table
resource_group = model.resource_group_table
q = select([res_rev], from_obj = res_rev.join(resource_group,
resource_group.c.id == res_rev.c.resource_group_id))
q = q.where(resource_group.c.package_id == pkg.id)
result = _execute_with_revision(q, res_rev, context)
result_dict["resources"] = resource_list_dictize(result, context)
result_dict['num_resources'] = len(result_dict.get('resources', []))
#tags
tag_rev = model.package_tag_revision_table
tag = model.tag_table
q = select([tag, tag_rev.c.state, tag_rev.c.revision_timestamp],
from_obj=tag_rev.join(tag, tag.c.id == tag_rev.c.tag_id)
).where(tag_rev.c.package_id == pkg.id)
result = _execute_with_revision(q, tag_rev, context)
result_dict["tags"] = d.obj_list_dictize(result, context, lambda x: x["name"])
result_dict['num_tags'] = len(result_dict.get('tags', []))
# Add display_names to tags. At first a tag's display_name is just the
# same as its name, but the display_name might get changed later (e.g.
# translated into another language by the multilingual extension).
for tag in result_dict['tags']:
assert not tag.has_key('display_name')
tag['display_name'] = tag['name']
#extras
extra_rev = model.extra_revision_table
q = select([extra_rev]).where(extra_rev.c.package_id == pkg.id)
result = _execute_with_revision(q, extra_rev, context)
result_dict["extras"] = extras_list_dictize(result, context)
#groups
member_rev = model.member_revision_table
group = model.group_table
q = select([group, member_rev.c.capacity],
from_obj=member_rev.join(group, group.c.id == member_rev.c.group_id)
).where(member_rev.c.table_id == pkg.id)\
.where(member_rev.c.state == 'active') \
.where(group.c.is_organization == False)
result = _execute_with_revision(q, member_rev, context)
context['with_capacity'] = False
## no package counts as cannot fetch from search index at the same
## time as indexing to it.
result_dict["groups"] = group_list_dictize(result, context,
with_package_counts=False)
#owning organization
group_rev = model.group_revision_table
q = select([group_rev]
).where(group_rev.c.id == pkg.owner_org) \
.where(group_rev.c.state == 'active')
result = _execute_with_revision(q, group_rev, context)
organizations = d.obj_list_dictize(result, context)
if organizations:
result_dict["organization"] = organizations[0]
else:
result_dict["organization"] = None
#relations
rel_rev = model.package_relationship_revision_table
q = select([rel_rev]).where(rel_rev.c.subject_package_id == pkg.id)
result = _execute_with_revision(q, rel_rev, context)
result_dict["relationships_as_subject"] = d.obj_list_dictize(result, context)
q = select([rel_rev]).where(rel_rev.c.object_package_id == pkg.id)
result = _execute_with_revision(q, rel_rev, context)
result_dict["relationships_as_object"] = d.obj_list_dictize(result, context)
# Extra properties from the domain object
# We need an actual Package object for this, not a PackageRevision
if isinstance(pkg, model.PackageRevision):
pkg = model.Package.get(pkg.id)
# isopen
result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen,bool) else pkg.isopen()
# type
# if null assign the default value to make searching easier
result_dict['type']= pkg.type or u'dataset'
# license
if pkg.license and pkg.license.url:
result_dict['license_url']= pkg.license.url
result_dict['license_title']= pkg.license.title.split('::')[-1]
elif pkg.license:
result_dict['license_title']= pkg.license.title
else:
result_dict['license_title']= pkg.license_id
# creation and modification date
result_dict['metadata_modified'] = pkg.metadata_modified.isoformat()
result_dict['metadata_created'] = pkg.metadata_created.isoformat() \
if pkg.metadata_created else None
return result_dict
def package_dictize(pkg, context):
'''
Given a Package object, returns an equivalent dictionary.
Normally this is the current revision (most recent moderated version),
but you can provide revision_id, revision_date or pending in the
context and it will filter to an earlier time or the latest unmoderated
object revision.
May raise NotFound. TODO: understand what the specific set of
circumstances are that cause this.
'''
model = context['model']
#package
package_rev = model.package_revision_table
q = select([package_rev]).where(package_rev.c.id == pkg.id)
result = _execute_with_revision(q, package_rev, context).first()
if not result:
raise logic.NotFound
result_dict = d.table_dictize(result, context)
#resources
res_rev = model.resource_revision_table
resource_group = model.resource_group_table
q = select([res_rev], from_obj = res_rev.join(resource_group,
resource_group.c.id == res_rev.c.resource_group_id))
q = q.where(resource_group.c.package_id == pkg.id)
result = _execute_with_revision(q, res_rev, context)
result_dict["resources"] = resource_list_dictize(result, context)
#tags
tag_rev = model.package_tag_revision_table
tag = model.tag_table
q = select([tag, tag_rev.c.state, tag_rev.c.revision_timestamp],
from_obj=tag_rev.join(tag, tag.c.id == tag_rev.c.tag_id)
).where(tag_rev.c.package_id == pkg.id)
result = _execute_with_revision(q, tag_rev, context)
result_dict["tags"] = d.obj_list_dictize(result, context, lambda x: x["name"])
#extras
extra_rev = model.extra_revision_table
q = select([extra_rev]).where(extra_rev.c.package_id == pkg.id)
result = _execute_with_revision(q, extra_rev, context)
result_dict["extras"] = extras_list_dictize(result, context)
#groups
member_rev = model.member_revision_table
group = model.group_table
q = select([group, member_rev.c.capacity],
from_obj=member_rev.join(group, group.c.id == member_rev.c.group_id)
).where(member_rev.c.table_id == pkg.id)\
.where(member_rev.c.state == 'active')
result = _execute_with_revision(q, member_rev, context)
result_dict["groups"] = d.obj_list_dictize(result, context)
#relations
rel_rev = model.package_relationship_revision_table
q = select([rel_rev]).where(rel_rev.c.subject_package_id == pkg.id)
result = _execute_with_revision(q, rel_rev, context)
result_dict["relationships_as_subject"] = d.obj_list_dictize(result, context)
q = select([rel_rev]).where(rel_rev.c.object_package_id == pkg.id)
result = _execute_with_revision(q, rel_rev, context)
result_dict["relationships_as_object"] = d.obj_list_dictize(result, context)
# Extra properties from the domain object
# We need an actual Package object for this, not a PackageRevision
if isinstance(pkg, ckan.model.PackageRevision):
pkg = model.Package.get(pkg.id)
# isopen
result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen,bool) else pkg.isopen()
# type
result_dict['type']= pkg.type
# licence
if pkg.license and pkg.license.url:
result_dict['license_url']= pkg.license.url
result_dict['license_title']= pkg.license.title.split('::')[-1]
elif pkg.license:
result_dict['license_title']= pkg.license.title
else:
result_dict['license_title']= pkg.license_id
# creation and modification date
result_dict['metadata_modified'] = context.pop('metadata_modified')
result_dict['metadata_created'] = pkg.metadata_created.isoformat() \
if pkg.metadata_created else None
if context.get('for_view'):
for item in plugins.PluginImplementations(plugins.IPackageController):
result_dict = item.before_view(result_dict)
return result_dict
def package_dictize(pkg, context):
'''
Given a Package object, returns an equivalent dictionary.
'''
model = context['model']
assert not (context.get('revision_id') or
context.get('revision_date')), \
'Revision functionality is moved to migrate_package_activity'
execute = _execute
# package
if not pkg:
raise logic.NotFound
result_dict = d.table_dictize(pkg, context)
# strip whitespace from title
if result_dict.get('title'):
result_dict['title'] = result_dict['title'].strip()
# resources
res = model.resource_table
q = select([res]).where(res.c.package_id == pkg.id)
result = execute(q, res, context)
result_dict["resources"] = resource_list_dictize(result, context)
result_dict['num_resources'] = len(result_dict.get('resources', []))
# tags
tag = model.tag_table
pkg_tag = model.package_tag_table
q = select([tag, pkg_tag.c.state],
from_obj=pkg_tag.join(tag, tag.c.id == pkg_tag.c.tag_id)
).where(pkg_tag.c.package_id == pkg.id)
result = execute(q, pkg_tag, context)
result_dict["tags"] = d.obj_list_dictize(result, context,
lambda x: x["name"])
result_dict['num_tags'] = len(result_dict.get('tags', []))
# Add display_names to tags. At first a tag's display_name is just the
# same as its name, but the display_name might get changed later (e.g.
# translated into another language by the multilingual extension).
for tag in result_dict['tags']:
assert 'display_name' not in tag
tag['display_name'] = tag['name']
# extras - no longer revisioned, so always provide latest
extra = model.package_extra_table
q = select([extra]).where(extra.c.package_id == pkg.id)
result = execute(q, extra, context)
result_dict["extras"] = extras_list_dictize(result, context)
# groups
member = model.member_table
group = model.group_table
q = select([group, member.c.capacity],
from_obj=member.join(group, group.c.id == member.c.group_id)
).where(member.c.table_id == pkg.id)\
.where(member.c.state == 'active') \
.where(group.c.is_organization == False)
result = execute(q, member, context)
context['with_capacity'] = False
# no package counts as cannot fetch from search index at the same
# time as indexing to it.
# tags, extras and sub-groups are not included for speed
result_dict["groups"] = group_list_dictize(result, context,
with_package_counts=False)
# owning organization
group = model.group_table
q = select([group]
).where(group.c.id == pkg.owner_org) \
.where(group.c.state == 'active')
result = execute(q, group, context)
organizations = d.obj_list_dictize(result, context)
if organizations:
result_dict["organization"] = organizations[0]
else:
result_dict["organization"] = None
# relations
rel = model.package_relationship_table
q = select([rel]).where(rel.c.subject_package_id == pkg.id)
result = execute(q, rel, context)
result_dict["relationships_as_subject"] = \
d.obj_list_dictize(result, context)
q = select([rel]).where(rel.c.object_package_id == pkg.id)
result = execute(q, rel, context)
result_dict["relationships_as_object"] = \
d.obj_list_dictize(result, context)
# Extra properties from the domain object
# isopen
result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen, bool) \
else pkg.isopen()
# type
# if null assign the default value to make searching easier
result_dict['type'] = pkg.type or u'dataset'
# license
if pkg.license and pkg.license.url:
result_dict['license_url'] = pkg.license.url
result_dict['license_title'] = pkg.license.title.split('::')[-1]
elif pkg.license:
result_dict['license_title'] = pkg.license.title
else:
result_dict['license_title'] = pkg.license_id
# creation and modification date
result_dict['metadata_modified'] = pkg.metadata_modified.isoformat()
result_dict['metadata_created'] = pkg.metadata_created.isoformat() \
if pkg.metadata_created else None
return result_dict
def package_dictize(pkg, context):
'''
Given a Package object, returns an equivalent dictionary.
'''
model = context['model']
assert not (context.get('revision_id') or
context.get('revision_date')), \
'Revision functionality is moved to migrate_package_activity'
assert not isinstance(pkg, model.PackageRevision), \
'Revision functionality is moved to migrate_package_activity'
execute = _execute
# package
if not pkg:
raise logic.NotFound
result_dict = d.table_dictize(pkg, context)
# strip whitespace from title
if result_dict.get('title'):
result_dict['title'] = result_dict['title'].strip()
# resources
res = model.resource_table
q = select([res]).where(res.c.package_id == pkg.id)
result = execute(q, res, context)
result_dict["resources"] = resource_list_dictize(result, context)
result_dict['num_resources'] = len(result_dict.get('resources', []))
# tags
tag = model.tag_table
pkg_tag = model.package_tag_table
q = select([tag, pkg_tag.c.state],
from_obj=pkg_tag.join(tag, tag.c.id == pkg_tag.c.tag_id)
).where(pkg_tag.c.package_id == pkg.id)
result = execute(q, pkg_tag, context)
result_dict["tags"] = d.obj_list_dictize(result, context,
lambda x: x["name"])
result_dict['num_tags'] = len(result_dict.get('tags', []))
# Add display_names to tags. At first a tag's display_name is just the
# same as its name, but the display_name might get changed later (e.g.
# translated into another language by the multilingual extension).
for tag in result_dict['tags']:
assert 'display_name' not in tag
tag['display_name'] = tag['name']
# extras - no longer revisioned, so always provide latest
extra = model.package_extra_table
q = select([extra]).where(extra.c.package_id == pkg.id)
result = _execute(q, extra, context)
result_dict["extras"] = extras_list_dictize(result, context)
# groups
member = model.member_table
group = model.group_table
q = select([group, member.c.capacity],
from_obj=member.join(group, group.c.id == member.c.group_id)
).where(member.c.table_id == pkg.id)\
.where(member.c.state == 'active') \
.where(group.c.is_organization == False)
result = execute(q, member, context)
context['with_capacity'] = False
# no package counts as cannot fetch from search index at the same
# time as indexing to it.
# tags, extras and sub-groups are not included for speed
result_dict["groups"] = group_list_dictize(result, context,
with_package_counts=False)
# owning organization
group = model.group_table
q = select([group]
).where(group.c.id == pkg.owner_org) \
.where(group.c.state == 'active')
result = execute(q, group, context)
organizations = d.obj_list_dictize(result, context)
if organizations:
result_dict["organization"] = organizations[0]
else:
result_dict["organization"] = None
# relations
rel = model.package_relationship_table
q = select([rel]).where(rel.c.subject_package_id == pkg.id)
result = execute(q, rel, context)
result_dict["relationships_as_subject"] = \
d.obj_list_dictize(result, context)
q = select([rel]).where(rel.c.object_package_id == pkg.id)
result = execute(q, rel, context)
result_dict["relationships_as_object"] = \
d.obj_list_dictize(result, context)
# Extra properties from the domain object
# isopen
result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen, bool) \
else pkg.isopen()
# type
# if null assign the default value to make searching easier
result_dict['type'] = pkg.type or u'dataset'
# license
if pkg.license and pkg.license.url:
result_dict['license_url'] = pkg.license.url
result_dict['license_title'] = pkg.license.title.split('::')[-1]
elif pkg.license:
result_dict['license_title'] = pkg.license.title
else:
result_dict['license_title'] = pkg.license_id
# creation and modification date
result_dict['metadata_modified'] = pkg.metadata_modified.isoformat()
result_dict['metadata_created'] = pkg.metadata_created.isoformat() \
if pkg.metadata_created else None
return result_dict
def package_dictize(pkg, context):
'''
Given a Package object, returns an equivalent dictionary.
Normally this is the most recent version, but you can provide revision_id
or revision_date in the context and it will filter to an earlier time.
May raise NotFound if:
* the specified revision_id doesn't exist
* the specified revision_date was before the package was created
'''
model = context['model']
is_latest_revision = not(context.get('revision_id') or
context.get('revision_date'))
execute = _execute if is_latest_revision else _execute_with_revision
#package
if is_latest_revision:
if isinstance(pkg, model.PackageRevision):
pkg = model.Package.get(pkg.id)
result = pkg
else:
package_rev = model.package_revision_table
q = select([package_rev]).where(package_rev.c.id == pkg.id)
result = execute(q, package_rev, context).first()
if not result:
raise logic.NotFound
result_dict = d.table_dictize(result, context)
#strip whitespace from title
if result_dict.get('title'):
result_dict['title'] = result_dict['title'].strip()
#resources
if is_latest_revision:
res = model.resource_table
else:
res = model.resource_revision_table
q = select([res]).where(res.c.package_id == pkg.id)
result = execute(q, res, context)
result_dict["resources"] = resource_list_dictize(result, context)
result_dict['num_resources'] = len(result_dict.get('resources', []))
#tags
tag = model.tag_table
if is_latest_revision:
pkg_tag = model.package_tag_table
else:
pkg_tag = model.package_tag_revision_table
q = select([tag, pkg_tag.c.state],
from_obj=pkg_tag.join(tag, tag.c.id == pkg_tag.c.tag_id)
).where(pkg_tag.c.package_id == pkg.id)
result = execute(q, pkg_tag, context)
result_dict["tags"] = d.obj_list_dictize(result, context,
lambda x: x["name"])
result_dict['num_tags'] = len(result_dict.get('tags', []))
# Add display_names to tags. At first a tag's display_name is just the
# same as its name, but the display_name might get changed later (e.g.
# translated into another language by the multilingual extension).
for tag in result_dict['tags']:
assert not 'display_name' in tag
tag['display_name'] = tag['name']
#extras
if is_latest_revision:
extra = model.package_extra_table
else:
extra = model.extra_revision_table
q = select([extra]).where(extra.c.package_id == pkg.id)
result = execute(q, extra, context)
result_dict["extras"] = extras_list_dictize(result, context)
#groups
if is_latest_revision:
member = model.member_table
else:
member = model.member_revision_table
group = model.group_table
q = select([group, member.c.capacity],
from_obj=member.join(group, group.c.id == member.c.group_id)
).where(member.c.table_id == pkg.id)\
.where(member.c.state == 'active') \
.where(group.c.is_organization == False)
result = execute(q, member, context)
context['with_capacity'] = False
## no package counts as cannot fetch from search index at the same
## time as indexing to it.
## tags, extras and sub-groups are not included for speed
result_dict["groups"] = group_list_dictize(result, context,
with_package_counts=False)
#owning organization
if is_latest_revision:
group = model.group_table
else:
group = model.group_revision_table
q = select([group]
).where(group.c.id == pkg.owner_org) \
.where(group.c.state == 'active')
result = execute(q, group, context)
organizations = d.obj_list_dictize(result, context)
if organizations:
result_dict["organization"] = organizations[0]
else:
result_dict["organization"] = None
#relations
if is_latest_revision:
rel = model.package_relationship_table
else:
rel = model.package_relationship_revision_table
q = select([rel]).where(rel.c.subject_package_id == pkg.id)
result = execute(q, rel, context)
result_dict["relationships_as_subject"] = \
d.obj_list_dictize(result, context)
q = select([rel]).where(rel.c.object_package_id == pkg.id)
result = execute(q, rel, context)
result_dict["relationships_as_object"] = \
d.obj_list_dictize(result, context)
# Extra properties from the domain object
# We need an actual Package object for this, not a PackageRevision
if isinstance(pkg, model.PackageRevision):
pkg = model.Package.get(pkg.id)
# isopen
result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen, bool) \
else pkg.isopen()
# type
# if null assign the default value to make searching easier
result_dict['type'] = pkg.type or u'dataset'
# license
if pkg.license and pkg.license.url:
result_dict['license_url'] = pkg.license.url
result_dict['license_title'] = pkg.license.title.split('::')[-1]
elif pkg.license:
result_dict['license_title'] = pkg.license.title
else:
result_dict['license_title'] = pkg.license_id
# creation and modification date
result_dict['metadata_modified'] = pkg.metadata_modified.isoformat()
result_dict['metadata_created'] = pkg.metadata_created.isoformat() \
if pkg.metadata_created else None
return result_dict
def package_dictize(pkg, context):
'''
Given a Package object, returns an equivalent dictionary.
Normally this is the current revision (most recent moderated version),
but you can provide revision_id, revision_date or pending in the
context and it will filter to an earlier time or the latest unmoderated
object revision.
May raise NotFound. TODO: understand what the specific set of
circumstances are that cause this.
'''
model = context['model']
#package
package_rev = model.package_revision_table
q = select([package_rev]).where(package_rev.c.id == pkg.id)
result = _execute_with_revision(q, package_rev, context).first()
if not result:
raise logic.NotFound
result_dict = d.table_dictize(result, context)
#strip whitespace from title
if result_dict.get('title'):
result_dict['title'] = result_dict['title'].strip()
#resources
res_rev = model.resource_revision_table
resource_group = model.resource_group_table
q = select([res_rev], from_obj = res_rev.join(resource_group,
resource_group.c.id == res_rev.c.resource_group_id))
q = q.where(resource_group.c.package_id == pkg.id)
result = _execute_with_revision(q, res_rev, context)
result_dict["resources"] = resource_list_dictize(result, context)
result_dict['num_resources'] = len(result_dict.get('resources', []))
#tags
tag_rev = model.package_tag_revision_table
tag = model.tag_table
q = select([tag, tag_rev.c.state, tag_rev.c.revision_timestamp],
from_obj=tag_rev.join(tag, tag.c.id == tag_rev.c.tag_id)
).where(tag_rev.c.package_id == pkg.id)
result = _execute_with_revision(q, tag_rev, context)
result_dict["tags"] = d.obj_list_dictize(result, context, lambda x: x["name"])
result_dict['num_tags'] = len(result_dict.get('tags', []))
# Add display_names to tags. At first a tag's display_name is just the
# same as its name, but the display_name might get changed later (e.g.
# translated into another language by the multilingual extension).
for tag in result_dict['tags']:
assert not tag.has_key('display_name')
tag['display_name'] = tag['name']
#extras
extra_rev = model.extra_revision_table
q = select([extra_rev]).where(extra_rev.c.package_id == pkg.id)
result = _execute_with_revision(q, extra_rev, context)
result_dict["extras"] = extras_list_dictize(result, context)
#groups
member_rev = model.member_revision_table
group = model.group_table
q = select([group, member_rev.c.capacity],
from_obj=member_rev.join(group, group.c.id == member_rev.c.group_id)
).where(member_rev.c.table_id == pkg.id)\
.where(member_rev.c.state == 'active') \
.where(group.c.is_organization == False)
result = _execute_with_revision(q, member_rev, context)
context['with_capacity'] = False
## no package counts as cannot fetch from search index at the same
## time as indexing to it.
## tags, extras and sub-groups are not included for speed
result_dict["groups"] = group_list_dictize(result, context,
with_package_counts=False)
#owning organization
group_rev = model.group_revision_table
q = select([group_rev]
).where(group_rev.c.id == pkg.owner_org) \
.where(group_rev.c.state == 'active')
result = _execute_with_revision(q, group_rev, context)
organizations = d.obj_list_dictize(result, context)
if organizations:
result_dict["organization"] = organizations[0]
else:
result_dict["organization"] = None
#relations
rel_rev = model.package_relationship_revision_table
q = select([rel_rev]).where(rel_rev.c.subject_package_id == pkg.id)
result = _execute_with_revision(q, rel_rev, context)
result_dict["relationships_as_subject"] = d.obj_list_dictize(result, context)
q = select([rel_rev]).where(rel_rev.c.object_package_id == pkg.id)
result = _execute_with_revision(q, rel_rev, context)
result_dict["relationships_as_object"] = d.obj_list_dictize(result, context)
# Extra properties from the domain object
# We need an actual Package object for this, not a PackageRevision
if isinstance(pkg, model.PackageRevision):
pkg = model.Package.get(pkg.id)
# isopen
result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen,bool) else pkg.isopen()
# type
# if null assign the default value to make searching easier
result_dict['type']= pkg.type or u'dataset'
# license
if pkg.license and pkg.license.url:
result_dict['license_url']= pkg.license.url
result_dict['license_title']= pkg.license.title.split('::')[-1]
elif pkg.license:
result_dict['license_title']= pkg.license.title
else:
result_dict['license_title']= pkg.license_id
# creation and modification date
result_dict['metadata_modified'] = pkg.metadata_modified.isoformat()
result_dict['metadata_created'] = pkg.metadata_created.isoformat() \
if pkg.metadata_created else None
return result_dict