def get_package_contacts(pkg_id):
"""
Returns contact information for the dataset with the given id.
:param pkg_id: the id of the package whose contact information to get
:return: a list of contact information dicts
:rtype: list of dicts
"""
contacts_regex = '^(contact)_(\d+)_(.+)$'
query = select(['id', 'key', 'value', 'state']).where(
and_(
model.PackageExtra.package_id == pkg_id,
model.PackageExtra.key.like('contact_%_%'),
model.PackageExtra.state == 'active'
)
)
extras = Session.execute(query)
extras = model_dictize.extras_list_dictize(extras, {'model': PackageExtra})
contacts_by_index = {}
for extra in extras:
key = extra['key']
value = extra['value']
match = re.match(contacts_regex, key)
if match:
index = match.group(2)
type = match.group(3)
contact = contacts_by_index.get(index, {})
contact[u'index'] = index
contact[type] = value
if type == 'email':
contact[u'id'] = extra['id']
contacts_by_index[index] = contact
contacts = [ c for c in contacts_by_index.values() ]
return sorted(contacts, key=lambda c: int(c['index']))
def get_package_id_by_data_pids(data_dict):
'''
Try if the provided data PIDs match exactly one dataset.
:param data_dict:
:return: Package id or None if not found.
'''
data_pids = get_pids_by_type('data', data_dict)
if len(data_pids) == 0:
return None
pid_list = [pid.get('id') for pid in data_pids]
# Get package ID's with matching PIDS
query = Session.query(model.PackageExtra.package_id.distinct()).\
filter(model.PackageExtra.value.in_(pid_list))
pkg_ids = query.all()
if len(pkg_ids) != 1:
return None # Nothing to do if we get many or zero datasets
# Get extras with the received package ID's
query = select(['key', 'value', 'state']).where(
and_(model.PackageExtra.package_id.in_(pkg_ids), model.PackageExtra.key.like('pids_%')))
extras = Session.execute(query)
# Dictize the results
extras = model_dictize.extras_list_dictize(extras, {'model': PackageExtra})
# Check that matching PIDS are type 'data'.
for extra in extras:
key = extra['key'].split('_') # eg. ('pids', '0', 'id')
if key[2] == 'id' and extra['value'] in pid_list:
type_key = '_'.join(key[:2] + ['type'])
if not filter(lambda x: x['key'] == type_key and x['value'] == 'data', extras):
return None # Found a hit with wrong type of PID
return pkg_ids[0] # No problems found, so use this
def package_dictize_with_revisions(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']
try:
model.PackageRevision
# CKAN<=2.8
revision_model = model
except AttributeError:
# CKAN>2.8
revision_model = RevisionTableMappings.instance()
is_latest_revision = not(context.get(u'revision_id') or
context.get(u'revision_date'))
execute = _execute if is_latest_revision else _execute_with_revision
# package
if is_latest_revision:
if isinstance(pkg, revision_model.PackageRevision):
pkg = model.Package.get(pkg.id)
result = pkg
else:
package_rev = revision_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(u'title'):
result_dict['title'] = result_dict['title'].strip()
# resources
if is_latest_revision:
res = model.resource_table
else:
res = revision_model.resource_revision_table
# metadata_modified was added after the revisioning was removed so
# it does not exist on the resource_revision table.
mm_col = res._columns.get(u'metadata_modified')
if mm_col is not None:
res._columns.remove(mm_col)
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(u'resources', []))
# tags
tag = model.tag_table
if is_latest_revision:
pkg_tag = model.package_tag_table
else:
pkg_tag = revision_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(u'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 u'display_name' not in tag
tag['display_name'] = tag['name']
# extras
if is_latest_revision:
extra = model.package_extra_table
else:
extra = revision_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 = revision_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 == u'active') \
.where(group.c.is_organization == False) # noqa
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 = revision_model.group_revision_table
q = select([group]
).where(group.c.id == result_dict['owner_org']) \
.where(group.c.state == u'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 = revision_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(u'::')[-1]
elif pkg.license:
result_dict['license_title'] = pkg.license.title
else:
result_dict['license_title'] = pkg.license_id
# creation and modification date
if is_latest_revision:
result_dict['metadata_modified'] = pkg.metadata_modified.isoformat()
# (If not is_latest_revision, don't use pkg which is the latest version.
# Instead, use the dates already in result_dict that came from the dictized
# PackageRevision)
result_dict['metadata_created'] = pkg.metadata_created.isoformat()
return result_dict
def package_dictize_with_revisions(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(u'revision_id') or
context.get(u'revision_date'))
execute = _execute if is_latest_revision else _execute_with_revision
# package
if is_latest_revision:
if isinstance(pkg, revision_model.PackageRevision):
pkg = model.Package.get(pkg.id)
result = pkg
else:
package_rev = revision_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(u'title'):
result_dict['title'] = result_dict['title'].strip()
# resources
if is_latest_revision:
res = model.resource_table
else:
res = revision_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(u'resources', []))
# tags
tag = model.tag_table
if is_latest_revision:
pkg_tag = model.package_tag_table
else:
pkg_tag = revision_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(u'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 u'display_name' not in tag
tag['display_name'] = tag['name']
# extras
if is_latest_revision:
extra = model.package_extra_table
else:
extra = revision_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 = revision_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 == u'active') \
.where(group.c.is_organization == False) # noqa
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 = revision_model.group_revision_table
q = select([group]
).where(group.c.id == result_dict['owner_org']) \
.where(group.c.state == u'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 = revision_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(u'::')[-1]
elif pkg.license:
result_dict['license_title'] = pkg.license.title
else:
result_dict['license_title'] = pkg.license_id
# creation and modification date
if is_latest_revision:
result_dict['metadata_modified'] = pkg.metadata_modified.isoformat()
# (If not is_latest_revision, don't use pkg which is the latest version.
# Instead, use the dates already in result_dict that came from the dictized
# PackageRevision)
result_dict['metadata_created'] = pkg.metadata_created.isoformat()
return result_dict
