def showcase_package_association_create(context, data_dict):
'''Create an association between a showcase and a package.
:param showcase_id: id or name of the showcase to associate
:type showcase_id: string
:param package_id: id or name of the package to associate
:type package_id: string
'''
toolkit.check_access('ckanext_showcase_package_association_create',
context, data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(
data_dict, showcase_package_association_create_schema(), context)
if errors:
raise toolkit.ValidationError(errors)
package_id, showcase_id = toolkit.get_or_bust(validated_data_dict,
['package_id',
'showcase_id'])
if ShowcasePackageAssociation.exists(package_id=package_id,
showcase_id=showcase_id):
raise toolkit.ValidationError("ShowcasePackageAssociation with package_id '{0}' and showcase_id '{1}' already exists.".format(package_id, showcase_id),
error_summary=u"The dataset, {0}, is already in the showcase".format(convert_package_name_or_id_to_title_or_name(package_id, context)))
# create the association
return ShowcasePackageAssociation.create(package_id=package_id,
showcase_id=showcase_id)
def organization_showcase_list(context, data_dict):
'''List showcases associated with an organization.
:param organization_id: id or name of the organization
:type organization_id: string
:rtype: list of dictionaries
'''
toolkit.check_access('ckanext_organization_showcase_list', context,
data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(data_dict,
organization_showcase_list_schema(),
context)
if errors:
raise toolkit.ValidationError(errors)
# get a list of showcase ids associated with the organization id
showcase_id_list = ShowcasePackageAssociation.get_showcase_ids_for_organization(
validated_data_dict['organization_id'])
showcase_list = []
if showcase_id_list is not None:
for item in showcase_id_list:
showcase_list.append(item.showcase_id)
return showcase_list
def showcase_package_association_delete(context, data_dict):
'''Delete an association between a showcase and a package.
:param showcase_id: id or name of the showcase in the association
:type showcase_id: string
:param package_id: id or name of the package in the association
:type package_id: string
'''
model = context['model']
toolkit.check_access('ckanext_showcase_package_association_delete',
context, data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(
data_dict, showcase_package_association_delete_schema(), context)
if errors:
raise toolkit.ValidationError(errors)
package_id, showcase_id = toolkit.get_or_bust(validated_data_dict,
['package_id',
'showcase_id'])
showcase_package_association = ShowcasePackageAssociation.get(
package_id=package_id, showcase_id=showcase_id)
if showcase_package_association is None:
raise toolkit.ObjectNotFound("ShowcasePackageAssociation with package_id '{0}' and showcase_id '{1}' doesn't exist.".format(package_id, showcase_id))
# delete the association
showcase_package_association.delete()
model.repo.commit()
def showcase_package_list(context, data_dict):
'''List packages associated with a showcase.
:param showcase_id: id or name of the showcase
:type showcase_id: string
:rtype: list of dictionaries
'''
toolkit.check_access('ckanext_showcase_package_list', context, data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(data_dict,
showcase_package_list_schema(),
context)
if errors:
raise toolkit.ValidationError(errors)
# get a list of package ids associated with showcase id
pkg_id_list = ShowcasePackageAssociation.get_package_ids_for_showcase(
validated_data_dict['showcase_id'])
pkg_list = []
if pkg_id_list is not None:
# for each package id, get the package dict and append to list if
# active
for pkg_id in pkg_id_list:
pkg = toolkit.get_action('package_show')(context, {'id': pkg_id})
if pkg['state'] == 'active':
pkg_list.append(pkg)
return pkg_list
def package_showcase_list(context, data_dict):
'''List showcases associated with a package.
:param package_id: id or name of the package
:type package_id: string
:rtype: list of dictionaries
'''
toolkit.check_access('ckanext_package_showcase_list', context, data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(data_dict,
package_showcase_list_schema(),
context)
if errors:
raise toolkit.ValidationError(errors)
# get a list of showcase ids associated with the package id
showcase_id_list = ShowcasePackageAssociation.get_showcase_ids_for_package(
validated_data_dict['package_id'])
showcase_list = []
if showcase_id_list is not None:
for showcase_id in showcase_id_list:
try:
showcase = toolkit.get_action('package_show')(context,
{'id': showcase_id})
showcase_list.append(showcase)
except NotAuthorized:
pass
return showcase_list
def package_showcase_list(context, data_dict):
'''List showcases associated with a package.
:param package_id: id or name of the package
:type package_id: string
:rtype: list of dictionaries
'''
toolkit.check_access('ckanext_package_showcase_list', context, data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(data_dict,
package_showcase_list_schema(),
context)
if errors:
raise toolkit.ValidationError(errors)
# get a list of showcase ids associated with the package id
showcase_id_list = ShowcasePackageAssociation.get_showcase_ids_for_package(
validated_data_dict['package_id'])
showcase_list = []
if showcase_id_list is not None:
for showcase_id in showcase_id_list:
showcase = toolkit.get_action('package_show')(context, {
'id': showcase_id
})
showcase_list.append(showcase)
return showcase_list
def showcase_package_list(context, data_dict):
'''List packages associated with a showcase.
:param showcase_id: id or name of the showcase
:type showcase_id: string
:rtype: list of dictionaries
'''
toolkit.check_access('ckanext_showcase_package_list', context, data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(data_dict,
showcase_package_list_schema(),
context)
if errors:
raise toolkit.ValidationError(errors)
# get a list of package ids associated with showcase id
pkg_id_list = ShowcasePackageAssociation.get_package_ids_for_showcase(
validated_data_dict['showcase_id'])
pkg_list = []
if pkg_id_list is not None:
# for each package id, get the package dict and append to list if
# active
for pkg_id in pkg_id_list:
pkg = toolkit.get_action('package_show')(context, {'id': pkg_id})
if pkg['state'] == 'active':
pkg_list.append(pkg)
return pkg_list
def showcase_package_association_create(context, data_dict):
'''Create an association between a showcase and a package.
:param showcase_id: id or name of the showcase to associate
:type showcase_id: string
:param package_id: id or name of the package to associate
:type package_id: string
'''
toolkit.check_access('ckanext_showcase_package_association_create',
context, data_dict)
# get organization id
pkg_dict = toolkit.get_action('package_show')(context, {
'id': data_dict['package_id']
})
if pkg_dict.get('organization'):
data_dict['organization_id'] = pkg_dict['organization']['id']
# validate the incoming data_dict
validated_data_dict, errors = validate(
data_dict, showcase_package_association_create_schema(), context)
if errors:
raise toolkit.ValidationError(errors)
package_id, showcase_id, organization_id = toolkit.get_or_bust(
validated_data_dict, ['package_id', 'showcase_id', 'organization_id'])
if ShowcasePackageAssociation.exists(package_id=package_id,
showcase_id=showcase_id):
raise toolkit.ValidationError(
"ShowcasePackageAssociation with package_id '{0}' and showcase_id '{1}' already exists."
.format(package_id, showcase_id),
error_summary=u"The dataset, {0}, is already in the showcase".
format(
convert_package_name_or_id_to_title_or_name(
package_id, context)))
# create the association
return ShowcasePackageAssociation.create(package_id=package_id,
showcase_id=showcase_id,
organization_id=organization_id)
def showcase_package_association_create(context, data_dict):
'''Create an association between a showcase and a package.
:param showcase_id: id or name of the showcase to associate
:type showcase_id: string
:param package_id: id or name of the package to associate
:type package_id: string
'''
toolkit.check_access('ckanext_showcase_package_association_create',
context, data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(
data_dict, showcase_package_association_create_schema(), context)
if errors:
raise toolkit.ValidationError(errors)
package_id, showcase_id = toolkit.get_or_bust(
validated_data_dict, ['package_id', 'showcase_id'])
if ShowcasePackageAssociation.exists(package_id=package_id,
showcase_id=showcase_id):
raise toolkit.ValidationError(
"ShowcasePackageAssociation with package_id '{0}' and showcase_id '{1}' already exists."
.format(package_id, showcase_id),
error_summary=u"The dataset, {0}, is already in the showcase".
format(
convert_package_name_or_id_to_title_or_name(
package_id, context)))
# Etsin: raise Validationerror if the showcase is already associated with a package
if len(
ShowcasePackageAssociation.get_package_ids_for_showcase(
showcase_id=showcase_id)) >= 1:
raise toolkit.ValidationError(
"Only one package association can be created for a showcase.")
# create the association
return ShowcasePackageAssociation.create(package_id=package_id,
showcase_id=showcase_id)
def hdx_get_package_showcase_id_list(context, data_dict):
import ckan.plugins.toolkit as toolkit
from ckan.lib.navl.dictization_functions import validate
from ckanext.showcase.logic.schema import (package_showcase_list_schema)
from ckanext.showcase.model import ShowcasePackageAssociation
toolkit.check_access('ckanext_package_showcase_list', context, data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(data_dict, package_showcase_list_schema(), context)
if errors:
raise toolkit.ValidationError(errors)
# get a list of showcase ids associated with the package id
showcase_id_list = ShowcasePackageAssociation.get_showcase_ids_for_package(validated_data_dict['package_id'])
return showcase_id_list
def package_showcase_list(context, data_dict):
'''List showcases associated with a package.
:param package_id: id or name of the package
:type package_id: string
:rtype: list of dictionaries
'''
toolkit.check_access('ckanext_package_showcase_list', context, data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(data_dict,
package_showcase_list_schema(),
context)
if errors:
raise toolkit.ValidationError(errors)
# get a list of showcase ids associated with the package id
showcase_id_list = ShowcasePackageAssociation.get_showcase_ids_for_package(
validated_data_dict['package_id'])
showcase_list = []
q = ''
fq = ''
if showcase_id_list:
id_list = []
for showcase_id in showcase_id_list:
id_list.append(showcase_id[0])
fq = 'dataset_type:showcase'
q = 'id:(' + ' OR '.join(['{0}'.format(x) for x in id_list]) + ')'
_showcase_list = toolkit.get_action('package_search')(context, {
'q': q,
'fq': fq,
'rows': 100
})
showcase_list = _showcase_list['results']
return showcase_list
def showcase_package_list(context, data_dict):
'''List packages associated with a showcase.
:param showcase_id: id or name of the showcase
:type showcase_id: string
:rtype: list of dictionaries
'''
toolkit.check_access('ckanext_showcase_package_list', context, data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(data_dict,
showcase_package_list_schema(),
context)
if errors:
raise toolkit.ValidationError(errors)
# get a list of package ids associated with showcase id
pkg_id_list = ShowcasePackageAssociation.get_package_ids_for_showcase(
validated_data_dict['showcase_id'])
pkg_list = []
if pkg_id_list:
# for each package id, get the package dict and append to list if
# active
id_list = []
for pkg_id in pkg_id_list:
id_list.append(pkg_id[0])
q = 'id:(' + ' OR '.join(['{0}'.format(x) for x in id_list]) + ')'
_pkg_list = toolkit.get_action('package_search')(context, {
'q': q,
'rows': 100
})
pkg_list = _pkg_list['results']
return pkg_list
def showcase_package_list(context, data_dict):
'''List packages associated with a showcase.
The context variable is passed forward as a copy to avoid unexpected side effects
:rtype: list of package dictionaries
'''
toolkit.check_access('ckanext_showcase_package_list', context.copy(),
data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(data_dict,
showcase_package_list_schema(),
context.copy())
if errors:
raise toolkit.ValidationError(errors)
# get a list of package ids associated with showcase id
pkg_id_list = ShowcasePackageAssociation.get_package_ids_for_showcase(
validated_data_dict['showcase_id'])
pkg_list = []
if pkg_id_list:
# for each package id, get the package dict and append to list if
# active
id_list = []
for pkg_id in pkg_id_list:
id_list.append(pkg_id[0])
q = ' OR '.join(['id:{0}'.format(x) for x in id_list])
_pkg_list = toolkit.get_action('package_search')(context, {
'q': q,
'rows': 100
})
pkg_list = _pkg_list['results']
return pkg_list
def showcase_package_association_delete(context, data_dict):
'''Delete an association between a showcase and a package.
:param showcase_id: id or name of the showcase in the association
:type showcase_id: string
:param package_id: id or name of the package in the association
:type package_id: string
'''
model = context['model']
toolkit.check_access('ckanext_showcase_package_association_delete',
context, data_dict)
# validate the incoming data_dict
validated_data_dict, errors = validate(
data_dict, showcase_package_association_delete_schema(), context)
if errors:
raise toolkit.ValidationError(errors)
package_id, showcase_id = toolkit.get_or_bust(
validated_data_dict, ['package_id', 'showcase_id'])
showcase_package_association = ShowcasePackageAssociation.get(
package_id=package_id, showcase_id=showcase_id)
if showcase_package_association is None:
raise toolkit.ObjectNotFound(
"ShowcasePackageAssociation with package_id '{0}' and showcase_id '{1}' doesn't exist."
.format(package_id, showcase_id))
# delete the association
showcase_package_association.delete()
model.repo.commit()
def _add_dataset_search(self, showcase_id, showcase_name):
'''
Search logic for discovering datasets to add to a showcase.
'''
from ckan.lib.search import SearchError
package_type = 'dataset'
# unicode format (decoded from utf8)
q = c.q = request.params.get('q', u'')
c.query_error = False
try:
page = self._get_page_number(request.params)
except AttributeError:
# in CKAN >= 2.5 _get_page_number has been moved
page = h.get_page_number(request.params)
limit = int(config.get('ckan.datasets_per_page', 20))
# most search operations should reset the page counter:
params_nopage = [(k, v) for k, v in request.params.items()
if k != 'page']
def drill_down_url(alternative_url=None, **by):
return h.add_url_param(alternative_url=alternative_url,
controller='package',
action='search',
new_params=by)
c.drill_down_url = drill_down_url
def remove_field(key, value=None, replace=None):
return h.remove_url_param(key,
value=value,
replace=replace,
controller='package',
action='search')
c.remove_field = remove_field
sort_by = request.params.get('sort', None)
params_nosort = [(k, v) for k, v in params_nopage if k != 'sort']
def _sort_by(fields):
"""
Sort by the given list of fields.
Each entry in the list is a 2-tuple: (fieldname, sort_order)
eg - [('metadata_modified', 'desc'), ('name', 'asc')]
If fields is empty, then the default ordering is used.
"""
params = params_nosort[:]
if fields:
sort_string = ', '.join('%s %s' % f for f in fields)
params.append(('sort', sort_string))
return self._search_url(params, showcase_name)
c.sort_by = _sort_by
if sort_by is None:
c.sort_by_fields = []
else:
c.sort_by_fields = [
field.split()[0] for field in sort_by.split(',')
]
def pager_url(q=None, page=None):
params = list(params_nopage)
params.append(('page', page))
return self._search_url(params, showcase_name)
c.search_url_params = urlencode(_encode_params(params_nopage))
try:
c.fields = []
# c.fields_grouped will contain a dict of params containing
# a list of values eg {'tags':['tag1', 'tag2']}
c.fields_grouped = {}
search_extras = {}
fq = ''
for (param, value) in request.params.items():
if param not in ['q', 'page', 'sort'] \
and len(value) and not param.startswith('_'):
if not param.startswith('ext_'):
c.fields.append((param, value))
fq += ' %s:"%s"' % (param, value)
if param not in c.fields_grouped:
c.fields_grouped[param] = [value]
else:
c.fields_grouped[param].append(value)
else:
search_extras[param] = value
context = {
'model': model,
'session': model.Session,
'user': c.user or c.author,
'for_view': True,
'auth_user_obj': c.userobj
}
if package_type and package_type != 'dataset':
# Only show datasets of this particular type
fq += ' +dataset_type:{type}'.format(type=package_type)
else:
# Unless changed via config options, don't show non standard
# dataset types on the default search page
if not tk.asbool(
config.get('ckan.search.show_all_types', 'False')):
fq += ' +dataset_type:dataset'
# Only search for packages that aren't already associated with the
# Showcase
associated_package_ids = ShowcasePackageAssociation.get_package_ids_for_showcase(
showcase_id)
# flatten resulting list to space separated string
if associated_package_ids:
associated_package_ids_str = \
' OR '.join([id[0] for id in associated_package_ids])
fq += ' !id:({0})'.format(associated_package_ids_str)
facets = OrderedDict()
default_facet_titles = {
'organization': _('Organizations'),
'groups': _('Groups'),
'tags': _('Tags'),
'res_format': _('Formats'),
'license_id': _('Licenses'),
}
# for CKAN-Versions that do not provide the facets-method from
# helper-context, import facets from ckan.common
if hasattr(h, 'facets'):
current_facets = h.facets()
else:
from ckan.common import g
current_facets = g.facets
for facet in current_facets:
if facet in default_facet_titles:
facets[facet] = default_facet_titles[facet]
else:
facets[facet] = facet
# Facet titles
for plugin in p.PluginImplementations(p.IFacets):
facets = plugin.dataset_facets(facets, package_type)
c.facet_titles = facets
data_dict = {
'q': q,
'fq': fq.strip(),
'facet.field': facets.keys(),
'rows': limit,
'start': (page - 1) * limit,
'sort': sort_by,
'extras': search_extras
}
query = get_action('package_search')(context, data_dict)
c.sort_by_selected = query['sort']
c.page = h.Page(collection=query['results'],
page=page,
url=pager_url,
item_count=query['count'],
items_per_page=limit)
c.facets = query['facets']
c.search_facets = query['search_facets']
c.page.items = query['results']
except SearchError, se:
log.error('Dataset search error: %r', se.args)
c.query_error = True
c.facets = {}
c.search_facets = {}
c.page = h.Page(collection=[])
def _add_dataset_search(self, showcase_id, showcase_name):
'''
Search logic for discovering datasets to add to a showcase.
'''
from ckan.lib.search import SearchError
package_type = 'dataset'
# unicode format (decoded from utf8)
q = c.q = request.params.get('q', u'')
c.query_error = False
try:
page = self._get_page_number(request.params)
except AttributeError:
# in CKAN >= 2.5 _get_page_number has been moved
page = h.get_page_number(request.params)
limit = int(config.get('ckan.datasets_per_page', 20))
# most search operations should reset the page counter:
params_nopage = [(k, v) for k, v in request.params.items()
if k != 'page']
def drill_down_url(alternative_url=None, **by):
return h.add_url_param(alternative_url=alternative_url,
controller='package', action='search',
new_params=by)
c.drill_down_url = drill_down_url
def remove_field(key, value=None, replace=None):
return h.remove_url_param(key, value=value, replace=replace,
controller='package', action='search')
c.remove_field = remove_field
sort_by = request.params.get('sort', None)
params_nosort = [(k, v) for k, v in params_nopage if k != 'sort']
def _sort_by(fields):
"""
Sort by the given list of fields.
Each entry in the list is a 2-tuple: (fieldname, sort_order)
eg - [('metadata_modified', 'desc'), ('name', 'asc')]
If fields is empty, then the default ordering is used.
"""
params = params_nosort[:]
if fields:
sort_string = ', '.join('%s %s' % f for f in fields)
params.append(('sort', sort_string))
return self._search_url(params, showcase_name)
c.sort_by = _sort_by
if sort_by is None:
c.sort_by_fields = []
else:
c.sort_by_fields = [field.split()[0]
for field in sort_by.split(',')]
def pager_url(q=None, page=None):
params = list(params_nopage)
params.append(('page', page))
return self._search_url(params, showcase_name)
c.search_url_params = urlencode(_encode_params(params_nopage))
try:
c.fields = []
# c.fields_grouped will contain a dict of params containing
# a list of values eg {'tags':['tag1', 'tag2']}
c.fields_grouped = {}
search_extras = {}
fq = ''
for (param, value) in request.params.items():
if param not in ['q', 'page', 'sort'] \
and len(value) and not param.startswith('_'):
if not param.startswith('ext_'):
c.fields.append((param, value))
fq += ' %s:"%s"' % (param, value)
if param not in c.fields_grouped:
c.fields_grouped[param] = [value]
else:
c.fields_grouped[param].append(value)
else:
search_extras[param] = value
context = {'model': model, 'session': model.Session,
'user': c.user or c.author, 'for_view': True,
'auth_user_obj': c.userobj}
if package_type and package_type != 'dataset':
# Only show datasets of this particular type
fq += ' +dataset_type:{type}'.format(type=package_type)
else:
# Unless changed via config options, don't show non standard
# dataset types on the default search page
if not tk.asbool(config.get('ckan.search.show_all_types',
'False')):
fq += ' +dataset_type:dataset'
# Only search for packages that aren't already associated with the
# Showcase
associated_package_ids = ShowcasePackageAssociation.get_package_ids_for_showcase(showcase_id)
# flatten resulting list to space separated string
if associated_package_ids:
associated_package_ids_str = \
' OR '.join([id[0] for id in associated_package_ids])
fq += ' !id:({0})'.format(associated_package_ids_str)
facets = OrderedDict()
default_facet_titles = {
'organization': _('Organizations'),
'groups': _('Groups'),
'tags': _('Tags'),
'res_format': _('Formats'),
'license_id': _('Licenses'),
}
# for CKAN-Versions that do not provide the facets-method from
# helper-context, import facets from ckan.common
if hasattr(h, 'facets'):
current_facets = h.facets()
else:
from ckan.common import g
current_facets = g.facets
for facet in current_facets:
if facet in default_facet_titles:
facets[facet] = default_facet_titles[facet]
else:
facets[facet] = facet
# Facet titles
for plugin in p.PluginImplementations(p.IFacets):
facets = plugin.dataset_facets(facets, package_type)
c.facet_titles = facets
data_dict = {
'q': q,
'fq': fq.strip(),
'facet.field': facets.keys(),
'rows': limit,
'start': (page - 1) * limit,
'sort': sort_by,
'extras': search_extras
}
query = get_action('package_search')(context, data_dict)
c.sort_by_selected = query['sort']
c.page = h.Page(
collection=query['results'],
page=page,
url=pager_url,
item_count=query['count'],
items_per_page=limit
)
c.facets = query['facets']
c.search_facets = query['search_facets']
c.page.items = query['results']
except SearchError, se:
log.error('Dataset search error: %r', se.args)
c.query_error = True
c.facets = {}
c.search_facets = {}
c.page = h.Page(collection=[])
def _add_dataset_search(showcase_id, showcase_name):
'''
Search logic for discovering datasets to add to a showcase.
'''
from ckan.lib.search import SearchError
package_type = 'dataset'
# unicode format (decoded from utf8)
q = tk.g.q = tk.request.params.get('q', u'')
tk.g.query_error = False
page = h.get_page_number(tk.request.params)
limit = int(tk.config.get('ckan.datasets_per_page', 20))
# most search operations should reset the page counter:
params_nopage = [(k, v) for k, v in tk.request.params.items()
if k != 'page']
def remove_field(key, value=None, replace=None):
return h.remove_url_param(key,
value=value,
replace=replace,
controller='dataset' if
tk.check_ckan_version('2.9') else 'package',
action='search')
tk.g.remove_field = remove_field
sort_by = tk.request.params.get('sort', None)
params_nosort = [(k, v) for k, v in params_nopage if k != 'sort']
def _sort_by(fields):
"""
Sort by the given list of fields.
Each entry in the list is a 2-tuple: (fieldname, sort_order)
eg - [('metadata_modified', 'desc'), ('name', 'asc')]
If fields is empty, then the default ordering is used.
"""
params = params_nosort[:]
if fields:
sort_string = ', '.join('%s %s' % f for f in fields)
params.append(('sort', sort_string))
return _search_url(params, showcase_name)
tk.g.sort_by = _sort_by
if sort_by is None:
tk.g.sort_by_fields = []
else:
tk.g.sort_by_fields = [
field.split()[0] for field in sort_by.split(',')
]
def pager_url(q=None, page=None):
params = list(params_nopage)
params.append(('page', page))
return _search_url(params, showcase_name)
tk.g.search_url_params = urlencode(_encode_params(params_nopage))
try:
tk.g.fields = []
# tk.g.fields_grouped will contain a dict of params containing
# a list of values eg {'tags':['tag1', 'tag2']}
tk.g.fields_grouped = {}
search_extras = {}
fq = ''
for (param, value) in tk.request.params.items():
if param not in ['q', 'page', 'sort'] \
and len(value) and not param.startswith('_'):
if not param.startswith('ext_'):
tk.g.fields.append((param, value))
fq += ' %s:"%s"' % (param, value)
if param not in tk.g.fields_grouped:
tk.g.fields_grouped[param] = [value]
else:
tk.g.fields_grouped[param].append(value)
else:
search_extras[param] = value
context = {
'model': model,
'session': model.Session,
'user': tk.g.user or tk.g.author,
'for_view': True,
'auth_user_obj': tk.g.userobj
}
# Unless changed via config options, don't show other dataset
# types any search page. Potential alternatives are do show them
# on the default search page (dataset) or on one other search page
search_all_type = tk.config.get('ckan.search.show_all_types')
search_all = False
try:
# If the "type" is set to True or False, convert to bool
# and we know that no type was specified, so use traditional
# behaviour of applying this only to dataset type
search_all = tk.asbool(search_all_type)
search_all_type = 'dataset'
# Otherwise we treat as a string representing a type
except ValueError:
search_all = True
if not search_all or package_type != search_all_type:
# Only show datasets of this particular type
fq += ' +dataset_type:{type}'.format(type=package_type)
# Only search for packages that aren't already associated with the
# Showcase
associated_package_ids = ShowcasePackageAssociation.get_package_ids_for_showcase(
showcase_id)
# flatten resulting list to space separated string
if associated_package_ids:
associated_package_ids_str = \
' OR '.join([id[0] for id in associated_package_ids])
fq += ' !id:({0})'.format(associated_package_ids_str)
facets = OrderedDict()
default_facet_titles = {
'organization': _('Organizations'),
'groups': _('Groups'),
'tags': _('Tags'),
'res_format': _('Formats'),
'license_id': _('Licenses'),
}
# for CKAN-Versions that do not provide the facets-method from
# helper-context, import facets from ckan.common
if hasattr(h, 'facets'):
current_facets = h.facets()
else:
from ckan.common import g
current_facets = g.facets
for facet in current_facets:
if facet in default_facet_titles:
facets[facet] = default_facet_titles[facet]
else:
facets[facet] = facet
# Facet titles
for plugin in p.PluginImplementations(p.IFacets):
facets = plugin.dataset_facets(facets, package_type)
tk.g.facet_titles = facets
data_dict = {
'q': q,
'fq': fq.strip(),
'facet.field': list(facets.keys()),
'rows': limit,
'start': (page - 1) * limit,
'sort': sort_by,
'extras': search_extras
}
query = tk.get_action('package_search')(context, data_dict)
tk.g.sort_by_selected = query['sort']
tk.g.page = h.Page(collection=query['results'],
page=page,
url=pager_url,
item_count=query['count'],
items_per_page=limit)
tk.g.facets = query['facets']
tk.g.search_facets = query['search_facets']
tk.g.page.items = query['results']
except SearchError as se:
log.error('Dataset search error: %r', se.args)
tk.g.query_error = True
tk.g.facets = {}
tk.g.search_facets = {}
tk.g.page = h.Page(collection=[])
tk.g.search_facets_limits = {}
for facet in tk.g.search_facets.keys():
try:
limit = int(
tk.request.params.get(
'_%s_limit' % facet,
int(tk.config.get('search.facets.default', 10))))
except tk.ValueError:
abort(
400,
_("Parameter '{parameter_name}' is not an integer").format(
parameter_name='_%s_limit' % facet))
tk.g.search_facets_limits[facet] = limit
