def my_pending_organizations():
"""
Publishers with pending for approval
:return:
"""
log.debug('dashboard pending orgainzations')
# Anonymous user should not be allowed to visit the link
context = {
u'model': model,
u'for_view': True,
u'user': g.user,
u'auth_user_obj': g.userobj
}
data_dict = {u'user_obj': g.userobj}
try:
if not c.user:
raise NotAuthorized
pending_organizations = iati_h.organization_list_pending()
extra_vars = _extra_template_variables(context, data_dict)
page = h.get_page_number(request.params) or 1
c.page = h.Page(
collection=pending_organizations,
page=page,
url=h.pager_url,
item_count=len(pending_organizations),
items_per_page=20,
)
extra_vars["page"] = c.page
extra_vars['pending_organizations'] = pending_organizations
return render('user/dashboard_pending_organizations.html', extra_vars)
except NotAuthorized:
p.toolkit.abort(
401,
_('Unauthorized to visit pending publisher page %s') % '')
def index(self):
group_type = self._guess_group_type()
page = h.get_page_number(request.params) or 1
items_per_page = 21
context = {
'model': model,
'session': model.Session,
'user': c.user,
'for_view': True,
'with_private': False
}
q = c.q = request.params.get('q', '')
sort_by = c.sort_by_selected = request.params.get('sort')
if sort_by is None:
sort_by = 'title asc'
try:
self._check_access('site_read', context)
self._check_access('group_list', context)
except NotAuthorized:
abort(403, _('Not authorized to see this page'))
# pass user info to context as needed to view private datasets of
# orgs correctly
if c.userobj:
context['user_id'] = c.userobj.id
context['user_is_admin'] = c.userobj.sysadmin
data_dict_global_results = {
'all_fields': False,
'q': q,
'sort': sort_by,
'type': group_type or 'group',
}
global_results = self._action('group_list')(context,
data_dict_global_results)
data_dict_page_results = {
'all_fields': True,
'q': q,
'sort': sort_by,
'type': group_type or 'group',
'limit': items_per_page,
'offset': items_per_page * (page - 1),
}
page_results = self._action('group_list')(context,
data_dict_page_results)
c.page = h.Page(
collection=global_results,
page=page,
url=h.pager_url,
items_per_page=items_per_page,
)
c.page.items = page_results
return render(self._index_template(group_type),
extra_vars={'group_type': group_type})
def dashboard_datasets(self):
"""User Dashboard > My Datasets pagination."""
context = {'for_view': True, 'user': c.user or c.author,
'auth_user_obj': c.userobj}
data_dict = {'user_obj': c.userobj, 'include_datasets': True}
try:
user_dict = logic.get_action('user_show')(context, data_dict)
except NotFound:
abort(404, _('User not found'))
except NotAuthorized:
abort(401, _('Not authorized to see this page'))
c.user_dict = user_dict
items_per_page = 20 # , readme
# check ckan version and call appropriate get_page number
if p.toolkit.check_ckan_version(min_version='2.5.0',
max_version='2.5.3'):
page = self._get_page_number(request.params) or 1
else:
page = h.get_page_number(request.params) or 1
c.page = h.Page(
collection=user_dict['datasets'],
page=page,
url=h.pager_url,
item_count=len(user_dict['datasets']),
items_per_page=items_per_page,
)
c.page.items = user_dict['datasets']
return render('user/dashboard_datasets.html')
def datasets():
"""
User Dashboard > My Datasets pagination.
"""
context = {u'for_view': True, u'user': g.user, u'auth_user_obj': g.userobj}
data_dict = {u'user_obj': g.userobj, u'include_datasets': True}
extra_vars = _extra_template_variables(context, data_dict)
items_per_page = 10 # , readme
# check ckan version and call appropriate get_page number
if p.toolkit.check_ckan_version(min_version='2.5.0', max_version='2.5.3'):
page = self._get_page_number(request.params) or 1
else:
page = h.get_page_number(request.params) or 1
c.page = h.Page(
collection=extra_vars['user_dict']['datasets'],
page=page,
url=h.pager_url,
item_count=len(extra_vars['user_dict']['datasets']),
items_per_page=items_per_page,
)
c.page.items = extra_vars['user_dict']['datasets']
return render(u'user/dashboard_datasets.html', extra_vars)
def index():
page_number = h.get_page_number(request.params)
q = request.params.get(u'q', u'')
order_by = request.params.get(u'order_by', u'name')
limit = int(
request.params.get(u'limit', config.get(u'ckan.user_list_limit', 20)))
context = {
u'return_query': True,
u'user': g.user,
u'auth_user_obj': g.userobj
}
data_dict = {
u'q': q,
u'order_by': order_by
}
try:
logic.check_access(u'user_list', context, data_dict)
except logic.NotAuthorized:
base.abort(403, _(u'Not authorized to see this page'))
users_list = logic.get_action(u'user_list')(context, data_dict)
page = h.Page(
collection=users_list,
page=page_number,
url=h.pager_url,
item_count=users_list.count(),
items_per_page=limit)
extra_vars = {u'page': page, u'q': q, u'order_by': order_by}
return base.render(u'user/list.html', extra_vars)
def index(self):
c.q = request.params.get("q", "")
context = {
"model": model,
"session": model.Session,
"user": c.user,
"auth_user_obj": c.userobj,
"for_view": True,
}
data_dict = {"all_fields": True}
if c.q:
page = h.get_page_number(request.params)
data_dict["q"] = c.q
data_dict["limit"] = LIMIT
data_dict["offset"] = (page - 1) * LIMIT
data_dict["return_objects"] = True
results = logic.get_action("tag_list")(context, data_dict)
if c.q:
c.page = h.Page(collection=results, page=page, item_count=len(results), items_per_page=LIMIT)
c.page.items = results
else:
c.page = AlphaPage(
collection=results, page=request.params.get("page", "A"), alpha_attribute="name", other_text=_("Other")
)
return base.render("tag/index.html")
def index(self):
custom_base.g_analitics()
group_type = self._guess_group_type()
page = h.get_page_number(request.params) or 1
items_per_page = 21
context = {'model': model, 'session': model.Session,
'user': c.user or c.author, 'for_view': True,
'with_private': False}
q = c.q = request.params.get('q', '')
sort_by = c.sort_by_selected = request.params.get('sort')
empty_string = ""
# default sort by number of organization's datasets
if sort_by is None or sort_by == empty_string:
sort_by = 'package_count desc'
try:
self._check_access('site_read', context)
except NotAuthorized:
abort(401, _('Not authorized to see this page'))
# pass user info to context as needed to view private datasets of
# orgs correctly
if c.userobj:
context['user_id'] = c.userobj.id
context['user_is_admin'] = c.userobj.sysadmin
data_dict_global_results = {
'all_fields': False,
'q': q,
'sort': sort_by,
'type': group_type or 'group',
}
global_results = self._action('group_list')(context,
data_dict_global_results)
data_dict_page_results = {
'all_fields': True,
'q': q,
'sort': sort_by,
'type': group_type or 'group',
'limit': items_per_page,
'offset': items_per_page * (page - 1),
}
page_results = self._action('group_list')(context,
data_dict_page_results)
c.page = h.Page(
collection=global_results,
page=page,
url=h.pager_url,
items_per_page=items_per_page,
)
c.page.items = page_results
return render(self._index_template(group_type),
extra_vars={'group_type': group_type})
def index(self):
page = h.get_page_number(request.params)
c.q = request.params.get('q', '')
c.order_by = request.params.get('order_by', 'name')
context = {
'return_query': True,
'user': c.user,
'auth_user_obj': c.userobj
}
data_dict = {'q': c.q, 'order_by': c.order_by}
limit = int(
request.params.get('limit', config.get('ckan.user_list_limit',
20)))
try:
check_access('user_list', context, data_dict)
except NotAuthorized:
abort(403, _('Not authorized to see this page'))
users_list = get_action('user_list')(context, data_dict)
c.page = h.Page(collection=users_list,
page=page,
url=h.pager_url,
item_count=users_list.count(),
items_per_page=limit)
return render('user/list.html')
def index(self):
page = h.get_page_number(request.params)
c.q = request.params.get('q', '')
c.order_by = request.params.get('order_by', 'name')
context = {'return_query': True, 'user': c.user,
'auth_user_obj': c.userobj}
data_dict = {'q': c.q,
'order_by': c.order_by}
limit = int(
request.params.get('limit', config.get('ckan.user_list_limit', 20))
)
try:
check_access('user_list', context, data_dict)
except NotAuthorized:
abort(403, _('Not authorized to see this page'))
users_list = get_action('user_list')(context, data_dict)
c.page = h.Page(
collection=users_list,
page=page,
url=h.pager_url,
item_count=users_list.count(),
items_per_page=limit
)
return render('user/list.html')
def index():
page_number = h.get_page_number(request.args)
q = request.args.get('q', '')
order_by = request.args.get('order_by', 'name')
default_limit: int = config.get_value('ckan.user_list_limit')
limit = int(request.args.get('limit', default_limit))
context = cast(
Context, {
u'return_query': True,
u'user': current_user.name,
u'auth_user_obj': current_user
})
data_dict = {u'q': q, u'order_by': order_by}
try:
logic.check_access(u'user_list', context, data_dict)
except logic.NotAuthorized:
base.abort(403, _(u'Not authorized to see this page'))
users_list = logic.get_action(u'user_list')(context, data_dict)
page = h.Page(collection=users_list,
page=page_number,
url=h.pager_url,
item_count=users_list.count(),
items_per_page=limit)
extra_vars: dict[str, Any] = {
u'page': page,
u'q': q,
u'order_by': order_by
}
return base.render(u'user/list.html', extra_vars)
def index():
page_number = h.get_page_number(request.params)
q = request.params.get(u'q', u'')
order_by = request.params.get(u'order_by', u'name')
limit = int(
request.params.get(u'limit', config.get(u'ckan.user_list_limit', 20)))
context = {
u'return_query': True,
u'user': g.user,
u'auth_user_obj': g.userobj
}
data_dict = {u'q': q, u'order_by': order_by}
try:
logic.check_access(u'user_list', context, data_dict)
except logic.NotAuthorized:
base.abort(403, _(u'Not authorized to see this page'))
users_list = logic.get_action(u'user_list')(context, data_dict)
page = h.Page(collection=users_list,
page=page_number,
url=h.pager_url,
item_count=users_list.count(),
items_per_page=limit)
extra_vars = {u'page': page, u'q': q, u'order_by': order_by}
return base.render(u'user/list.html', extra_vars)
def index(self):
c.q = request.params.get('q', '')
context = {'model': model, 'session': model.Session,
'user': c.user, 'auth_user_obj': c.userobj,
'for_view': True}
data_dict = {'all_fields': True}
if c.q:
page = h.get_page_number(request.params)
data_dict['q'] = c.q
data_dict['limit'] = LIMIT
data_dict['offset'] = (page - 1) * LIMIT
data_dict['return_objects'] = True
results = logic.get_action('tag_list')(context, data_dict)
if c.q:
c.page = h.Page(
collection=results,
page=page,
item_count=len(results),
items_per_page=LIMIT
)
c.page.items = results
else:
c.page = AlphaPage(
collection=results,
page=request.params.get('page', 'A'),
alpha_attribute='name',
other_text=_('Other'),
)
return base.render('tag/index.html')
def my_organizations():
log.debug('dashboard my orgainzations')
context = {
u'model': model,
u'for_view': True,
u'user': g.user,
u'auth_user_obj': g.userobj
}
data_dict = {u'user_obj': g.userobj}
try:
if not c.user:
raise NotAuthorized
organizations = iati_h.organizations_available_with_extra_fields()
extra_vars = _extra_template_variables(context, data_dict)
page = h.get_page_number(request.params) or 1
c.page = h.Page(
collection=organizations,
page=page,
url=h.pager_url,
item_count=len(organizations),
items_per_page=20,
)
extra_vars["page"] = c.page
extra_vars['organizations'] = organizations
return render('user/my_organizations.html', extra_vars)
except NotAuthorized:
p.toolkit.abort(401,
_('Unauthorized to visit my publisher page %s') % '')
def activity(self):
do_if_user_not_sysadmin()
page = get_page_number(tk.request.params)
total_rows = App.all().count()
total_pages = ((total_rows - 1) / self.paginated_by + 1) or 1
# redirect for delete page parameter reason
if not 0 < page <= total_pages:
redirect_to('apps_activity')
apps_activity = App.all().order_by(App.created.desc()).offset(
(page - 1) * self.paginated_by).limit(self.paginated_by)
activity = [
dict(id=i.id,
url=i.get_absolute_url(),
content=i.content,
name=i.name,
status=i.status,
author_name=i.author.name,
created=i.created) for i in apps_activity
]
c.page = Page(collection=apps_activity,
page=page,
item_count=total_rows,
items_per_page=self.paginated_by)
context = {
'activity': sorted(activity,
key=itemgetter('created'),
reverse=True),
'statuses': STATUSES,
}
return self.__render('apps_activity.html', context)
def index(self):
context = {
'model': model,
'session': model.Session,
'user': g.user,
'auth_user_obj': g.userobj
}
# Package needs to have a organization group in the call to
# check_access and also to save it
try:
logic.check_access('sysadmin', context, {})
except logic.NotAuthorized:
base.abort(403, _('Need to be system administrator'))
page = h.get_page_number(request.params)
total = model.Session.query(SearchQuery).count()
queries = model.Session.query(SearchQuery).order_by(
SearchQuery.count.desc()
).limit(PER_PAGE).offset((page - 1) * PER_PAGE)
pager = h.Page(
collection=queries,
page=page,
url=lambda page: h.url_for('search_queries.index', page=page),
item_count=total,
items_per_page=PER_PAGE
)
return render(
'search_queries/index.html', {
'queries': queries,
'pager': pager
}
)
def organization_dashboard(self, name):
org = get_action('organization_show')({}, {'id': name, 'include_extras': True})
if 'orgdashboards_is_active' in org and org['orgdashboards_is_active'] == '0':
return plugins.toolkit.render('dashboards/snippets/not_active.html')
from ckan.lib.search import SearchError
package_type = 'dataset'
try:
context = {'model': model, 'user': c.user or c.author,
'auth_user_obj': c.userobj}
check_access('site_read', context)
except NotAuthorized:
abort(401, _('Not authorized to see this page'))
# unicode format (decoded from utf8)
q = c.q = request.params.get('q', u'')
c.query_error = False
if p.toolkit.check_ckan_version(min_version='2.5.0', max_version='2.5.3'):
page = self._get_page_number(request.params)
else:
page = h.get_page_number(request.params)
try:
limit = int(org['orgdashboards_datasets_per_page'])
except KeyError, ValueError:
limit = int(config.get('ckanext.orgdashboards.datasets_per_page', '6'))
def index(self):
page = h.get_page_number(request.params) or 1
items_per_page = 21
context = {
'model': model,
'session': model.Session,
'user': c.user,
'for_view': True,
'with_private': False
}
q = c.q = request.params.get('q', '')
sort_by = c.sort_by_selected = request.params.get('sort')
try:
tk.check_access('basket_list', context, {})
except NotAuthorized:
abort(403, _('Not authorized to see this page'))
# pass user info to context as needed to view private datasets of
# orgs correctly
if c.userobj:
context['user_id'] = c.userobj.id
context['user_is_admin'] = c.userobj.sysadmin
try:
data_dict_global_results = {
'all_fields': False,
'q': q,
'sort': sort_by,
}
global_results = tk.get_action('basket_list')(
context, data_dict_global_results)
except ValidationError as e:
if e.error_dict and e.error_dict.get('message'):
msg = e.error_dict['message']
else:
msg = str(e)
h.flash_error(msg)
c.page = h.Page([], 0)
# return render(self._index_template(group_type),
# extra_vars={'group_type': group_type})
page_results = tk.get_action('basket_list')(context, {})
c.page = h.Page(
collection=global_results,
page=page,
url=h.pager_url,
items_per_page=items_per_page,
)
c.page.items = page_results
return tk.render('basket/index.html', {'title': 'Baskets'})
def embed(self, id, limit=5):
"""
Fetch given organization's packages and show them in an embeddable list view.
See Nginx config for X-Frame-Options SAMEORIGIN header modifications.
"""
def make_pager_url(q=None, page=None):
ctrlr = 'ckanext.ytp.controller:YtpOrganizationController'
url = h.url_for(controller=ctrlr, action='embed', id=id)
return url + u'?page=' + str(page)
try:
context = {
'model': model,
'session': model.Session,
'user': c.user or c.author
}
check_access('group_show', context, {'id': id})
except NotFound:
abort(404, _('Group not found'))
except NotAuthorized:
g = model.Session.query(
model.Group).filter(model.Group.name == id).first()
if g is None or g.state != 'active':
return self._render_template(
'group/organization_not_found.html')
page = h.get_page_number(request.params) or 1
group_dict = {'id': id}
group_dict['include_datasets'] = False
c.group_dict = self._action('group_show')(context, group_dict)
c.group = context['group']
q = c.q = request.params.get('q', '')
q += ' owner_org:"%s"' % c.group_dict.get('id')
data_dict = {
'q': q,
'rows': limit,
'start': (page - 1) * limit,
'extras': {}
}
query = get_action('package_search')(context, data_dict)
c.page = h.Page(collection=query['results'],
page=page,
url=make_pager_url,
item_count=query['count'],
items_per_page=limit)
c.page.items = query['results']
return render("organization/embed.html")
def subdashboardpage_show(self, org_name, subdashboard_name):
data_dict = {'id': org_name, 'include_extras': True}
org = get_action('organization_show')({}, data_dict)
subdashboards_list = get_action('orgportals_pages_show')({}, {'org_name': org_name, 'page_name': 'data'})
subdashboards_topics = json.loads(subdashboards_list['topics'])
subdashboards_dict = {x['subdashboard']: x for x in subdashboards_topics}
data_dict = {'org_name': org_name, 'subdashboard_name': subdashboard_name}
subdashboard = get_action('orgportals_subdashboards_show')({}, data_dict)
subdashboard['subdashboard_title'] = subdashboards_dict[subdashboard['name']]['title']
org['subdashboards'] = subdashboards_topics
if not _is_portal_active(org_name):
extra_vars = {'type': 'portal'}
return p.toolkit.render('portals/snippets/not_active.html', extra_vars=extra_vars)
if 'is_active' in subdashboard and subdashboard['is_active'] == False:
extra_vars = {'type': 'subdashboard'}
return p.toolkit.render('portals/snippets/not_active.html', extra_vars=extra_vars)
package_type = 'dataset'
try:
context = {
'model': model,
'user': c.user or c.author,
'auth_user_obj': c.userobj
}
check_access('site_read', context)
except p.toolkit.NotAuthorized:
p.toolkit.abort(401, _('Not authorized to see this page'))
# unicode format (decoded from utf8)
q = c.q = request.params.get('q', u'')
c.query_error = False
# check ckan version and call appropriate get_page number
if p.toolkit.check_ckan_version(min_version='2.5.0',
max_version='2.5.3'):
page = self._get_page_number(request.params)
else:
page = h.get_page_number(request.params)
try:
limit = int(org['orgportals_datasets_per_page'])
except KeyError, ValueError:
limit = int(config.get('ckanext.orgportals.datasets_per_page',
'6'))
def index(self):
group_type = self._guess_group_type()
page = h.get_page_number(request.params) or 1
items_per_page = 21
context = {'model': model, 'session': model.Session,
'user': c.user or c.author, 'for_view': True,
'with_private': False}
q = c.q = request.params.get('q', '')
sort_by = c.sort_by_selected = request.params.get('sort')
try:
self._check_access('site_read', context)
except NotAuthorized:
abort(401, _('Not authorized to see this page'))
# pass user info to context as needed to view private datasets of
# orgs correctly
if c.userobj:
context['user_id'] = c.userobj.id
context['user_is_admin'] = c.userobj.sysadmin
data_dict_global_results = {
'all_fields': False,
'q': q,
'sort': sort_by,
'type': group_type or 'group',
}
global_results = self._action('group_list')(context,
data_dict_global_results)
data_dict_page_results = {
'all_fields': True,
'include_extras': True,
'q': q,
'sort': sort_by,
'type': group_type or 'group'
}
page_results = self._action('group_list')(context,
data_dict_page_results)
c.page = h.Page(
collection=global_results,
page=page,
url=h.pager_url,
items_per_page=items_per_page,
)
c.page.items = page_results
return render(self._index_template(group_type),
extra_vars={'group_type': group_type})
def custom(self):
q = request.params.get('q', u'')
fq = ''
search_params = {}
for (param, value) in request.params.items():
if param not in ['q', 'page', 'sort'] \
and len(value) and not param.startswith('_'):
search_params[param] = value
fq += ' %s:"%s"' % (param, value)
page = h.get_page_number(request.params)
limit = ITEMS_LIMIT
data_dict = {
'q': q,
'fq': fq,
'start': (page - 1) * limit,
'rows': limit,
'sort': request.params.get('sort', None),
}
item_count, results = _package_search(data_dict)
navigation_urls = self._navigation_urls(request.params,
item_count=item_count,
limit=data_dict['rows'],
controller='feed',
action='custom')
feed_url = self._feed_url(request.params,
controller='feed',
action='custom')
atom_url = h._url_with_params('/feeds/custom.atom',
search_params.items())
alternate_url = self._alternate_url(request.params)
site_title = config.get('ckan.site_title', 'CKAN')
return self.output_feed(results,
feed_title=u'%s - Custom query' % site_title,
feed_description=u'Recently created or updated'
' datasets on %s. Custom query: \'%s\'' %
(site_title, q),
feed_link=alternate_url,
feed_guid=_create_atom_id(atom_url),
feed_url=feed_url,
navigation_urls=navigation_urls)
def custom(self):
q = request.params.get('q', u'')
fq = ''
search_params = {}
for (param, value) in request.params.items():
if param not in ['q', 'page', 'sort'] \
and len(value) and not param.startswith('_'):
search_params[param] = value
fq += ' %s:"%s"' % (param, value)
page = h.get_page_number(request.params)
limit = ITEMS_LIMIT
data_dict = {
'q': q,
'fq': fq,
'start': (page - 1) * limit,
'rows': limit,
'sort': request.params.get('sort', None),
}
item_count, results = _package_search(data_dict)
navigation_urls = self._navigation_urls(request.params,
item_count=item_count,
limit=data_dict['rows'],
controller='feed',
action='custom')
feed_url = self._feed_url(request.params,
controller='feed',
action='custom')
atom_url = h._url_with_params('/feeds/custom.atom',
search_params.items())
alternate_url = self._alternate_url(request.params)
site_title = config.get('ckan.site_title', 'CKAN')
return self.output_feed(results,
feed_title=u'%s - Custom query' % site_title,
feed_description=u'Recently created or updated'
' datasets on %s. Custom query: \'%s\'' %
(site_title, q),
feed_link=alternate_url,
feed_guid=_create_atom_id(atom_url),
feed_url=feed_url,
navigation_urls=navigation_urls)
def custom():
"""
Custom atom feed
"""
q = request.params.get(u'q', u'')
fq = u''
search_params = {}
for (param, value) in request.params.items():
if param not in [u'q', u'page', u'sort'] \
and len(value) and not param.startswith(u'_'):
search_params[param] = value
fq += u'%s:"%s"' % (param, value)
page = h.get_page_number(request.params)
limit = ITEMS_LIMIT
data_dict = {
u'q': q,
u'fq': fq,
u'start': (page - 1) * limit,
u'rows': limit,
u'sort': request.params.get(u'sort', None)
}
item_count, results = _package_search(data_dict)
navigation_urls = _navigation_urls(
request.params,
item_count=item_count,
limit=data_dict['rows'],
controller=u'feeds',
action=u'custom')
feed_url = _feed_url(request.params, controller=u'feeds', action=u'custom')
atom_url = h._url_with_params(u'/feeds/custom.atom', search_params.items())
alternate_url = _alternate_url(request.params)
return output_feed(
results,
feed_title=u'%s - Custom query' % SITE_TITLE,
feed_description=u'Recently created or updated'
' datasets on %s. Custom query: \'%s\'' % (SITE_TITLE, q),
feed_link=alternate_url,
feed_guid=_create_atom_id(atom_url),
feed_url=feed_url,
navigation_urls=navigation_urls)
def custom():
"""
Custom atom feed
"""
q = request.params.get(u'q', u'')
fq = u''
search_params = {}
for (param, value) in request.params.items():
if param not in [u'q', u'page', u'sort'] \
and len(value) and not param.startswith(u'_'):
search_params[param] = value
fq += u'%s:"%s"' % (param, value)
page = h.get_page_number(request.params)
limit = ITEMS_LIMIT
data_dict = {
u'q': q,
u'fq': fq,
u'start': (page - 1) * limit,
u'rows': limit,
u'sort': request.params.get(u'sort', None)
}
item_count, results = _package_search(data_dict)
navigation_urls = _navigation_urls(
request.params,
item_count=item_count,
limit=data_dict['rows'],
controller=u'feeds',
action=u'custom')
feed_url = _feed_url(request.params, controller=u'feeds', action=u'custom')
atom_url = h._url_with_params(u'/feeds/custom.atom', search_params.items())
alternate_url = _alternate_url(request.params)
return output_feed(
results,
feed_title=u'%s - Custom query' % SITE_TITLE,
feed_description=u'Recently created or updated'
' datasets on %s. Custom query: \'%s\'' % (SITE_TITLE, q),
feed_link=alternate_url,
feed_guid=_create_atom_id(atom_url),
feed_url=feed_url,
navigation_urls=navigation_urls)
def index(self):
page = get_page_number(tk.request.params)
total_rows = Thread.all().count()
total_pages = ((Thread.all().count() - 1) / self.paginated_by + 1) or 1
if not 0 < page <= total_pages:
# redirect for delete page parameter reason
redirect_to('forum_index')
thread_list = Thread.all().offset(
(page - 1) * self.paginated_by).limit(self.paginated_by)
c.page = Page(collection=thread_list,
page=page,
item_count=total_rows,
items_per_page=self.paginated_by)
return self.__render('forum_index.html', {'thread_list': thread_list})
def index():
u''' dashboards index view function '''
extra_vars = {}
context = _get_context()
try:
check_access(u'dashboard_list', context)
except NotAuthorized:
base.abort(403, _(u'Not authorized to see this page'))
page = h.get_page_number(request.params) or 1
items_per_page = int(
config.get(u'ckanext.'
u'knowledgehub.dashboards_per_page', 10))
q = request.params.get(u'q', u'')
sort_by = request.params.get(u'sort', u'name asc')
data_dict_global_results = {u'q': q, u'sort': sort_by}
data_dict_page_results = {
u'q': q,
u'sort': sort_by,
u'limit': items_per_page,
u'offset': items_per_page * (page - 1)
}
extra_vars["q"] = q
extra_vars["sort_by_selected"] = sort_by
global_results = get_action(u'dashboard_list')(context,
data_dict_global_results)
context.pop('ignore_auth', None)
context.pop('__auth_user_obj_checked', None)
page_results = get_action(u'dashboard_list')(context,
data_dict_page_results)
extra_vars["page"] = h.Page(collection=global_results['data'],
page=page,
url=h.pager_url,
items_per_page=items_per_page)
extra_vars['page'].items = page_results['data']
return base.render(u'dashboard/index.html', extra_vars=extra_vars)
def index():
u''' Themes index view function '''
extra_vars = {}
context = _get_context()
# TODO add appropriate check
# try:
# check_access(u'theme_list', context)
# except NotAuthorized:
# base.abort(403, _(u'Not authorized to see this page'))
page = h.get_page_number(request.params) or 1
items_per_page = int(
config.get(u'ckanext.'
u'knowledgehub.themes_per_page', 10))
q = request.params.get(u'q', u'')
sort_by = request.params.get(u'sort', u'name asc')
data_dict_global_results = {u'q': q, u'sort': sort_by}
data_dict_page_results = {
u'q': q,
u'sort': sort_by,
u'limit': items_per_page,
u'offset': items_per_page * (page - 1)
}
extra_vars["q"] = q
extra_vars["sort_by_selected"] = sort_by
global_results = get_action(u'theme_list')(context,
data_dict_global_results)
page_results = get_action(u'theme_list')(context, data_dict_page_results)
extra_vars["page"] = h.Page(
collection=global_results['data'],
page=page,
url=h.pager_url,
items_per_page=items_per_page,
)
extra_vars['page'].items = page_results['data']
return base.render(u'theme/index.html', extra_vars=extra_vars)
def _parse_url_params():
"""
Constructs a search-query dict from the URL query parameters.
Returns the constructed search-query dict, and the valid URL
query parameters.
"""
page = h.get_page_number(request.params)
limit = ITEMS_LIMIT
data_dict = {u'start': (page - 1) * limit, u'rows': limit}
# Filter ignored query parameters
valid_params = ['page']
params = dict((p, request.params.get(p)) for p in valid_params
if p in request.params)
return data_dict, params
def _parse_url_params() -> tuple[dict[str, Any], dict[str, Any]]:
"""
Constructs a search-query dict from the URL query parameters.
Returns the constructed search-query dict, and the valid URL
query parameters.
"""
page = h.get_page_number(request.args)
limit = config.get_value('ckan.feeds.limit')
data_dict = {u'start': (page - 1) * limit, u'rows': limit}
# Filter ignored query parameters
valid_params = ['page']
params = dict(
(p, request.args.get(p)) for p in valid_params if p in request.args)
return data_dict, params
def _parse_url_params(self):
"""
Constructs a search-query dict from the URL query parameters.
Returns the constructed search-query dict, and the valid URL
query parameters.
"""
page = h.get_page_number(request.params)
limit = ITEMS_LIMIT
data_dict = {'start': (page - 1) * limit, 'rows': limit}
# Filter ignored query parameters
valid_params = ['page']
params = dict((p, request.params.get(p)) for p in valid_params
if p in request.params)
return data_dict, params
def thread_show(self, slug, id):
thread = Thread.get_by_id(id=id)
if not thread:
abort(404)
if not thread.active and (not c.userobj or not c.userobj.sysadmin):
abort(404)
form = CreatePostForm(tk.request.POST)
if tk.request.POST:
if c.userobj is None:
tk.redirect_to(tk.url_for(controller='user', action='login'))
if BannedUser.check_by_id(c.userobj):
flash_error(tk._('You are banned'))
tk.redirect_to(thread.get_absolute_url())
if form.validate():
post = tk.get_action('forum_create_post')(
{
'auth_user_obj': c.userobj
}, {
'thread_id': id,
'content': form.data['content']
})
if post:
jobs.enqueue(
send_notifications_on_new_post,
[post, tk.request.environ.get('CKAN_LANG')])
flash_success(tk._('You successfully create comment'))
else:
flash_error(tk._('Thread is closed for comments'))
return tk.redirect_to(thread.get_absolute_url())
else:
flash_error(tk._('You have errors in form'))
page = get_page_number(tk.request.params)
total_rows = Post.filter_thread(thread.id).count()
total_pages = (total_rows / self.paginated_by + 1) or 1
if not 0 < page <= total_pages:
# redirect for delete page parameter reason
redirect_to('forum_index')
posts_list = Post.filter_thread(thread.id).offset(
(page - 1) * self.paginated_by).limit(self.paginated_by)
c.page = Page(collection=posts_list,
page=page,
item_count=total_rows,
items_per_page=self.paginated_by)
context = {'thread': thread, 'form': form, 'posts': posts_list}
return self.__render('thread.html', context)
def datapage_show(self, org_name):
data_dict = {'id': org_name, 'include_extras': True}
org = get_action('organization_show')({}, data_dict)
if not _is_portal_active(org_name):
extra_vars = {'type': 'portal'}
return p.toolkit.render('portals/snippets/not_active.html',
extra_vars=extra_vars)
package_type = 'dataset'
c.page_name = 'data'
c.org_name = org_name
try:
context = {
'model': model,
'user': c.user or c.author,
'auth_user_obj': c.userobj
}
check_access('site_read', context)
except p.toolkit.NotAuthorized:
p.toolkit.abort(401, _('Not authorized to see this page'))
# unicode format (decoded from utf8)
q = c.q = request.params.get('q', u'')
c.query_error = False
# check ckan version and call appropriate get_page number
if p.toolkit.check_ckan_version(min_version='2.5.0',
max_version='2.5.3'):
page = self._get_page_number(request.params)
else:
page = h.get_page_number(request.params)
try:
limit = int(org['orgportals_datasets_per_page'])
except KeyError, ValueError:
limit = int(config.get('ckanext.orgportals.datasets_per_page',
'6'))
def board_show(self, slug):
board = Board.get_by_slug(slug)
if not board:
abort(404)
page = get_page_number(tk.request.params)
total_rows = Thread.filter_board(board_slug=board.slug).count()
total_pages = (total_rows / self.paginated_by + 1) or 1
if not 0 < page <= total_pages:
# redirect for delete page parameter reason
redirect_to('forum_index')
thread_list = Thread.filter_board(board_slug=board.slug).offset(
(page - 1) * self.paginated_by).limit(self.paginated_by)
c.page = Page(collection=thread_list,
page=page,
item_count=total_rows,
items_per_page=self.paginated_by)
return self.__render('forum_index.html', {
'board': board,
'thread_list': thread_list
})
def get(self):
page = h.get_page_number(request.params)
total = model.Session.query(SearchQuery).count()
queries = model.Session.query(SearchQuery).order_by(
SearchQuery.count.desc()
).limit(PER_PAGE).offset((page - 1) * PER_PAGE)
pager = h.Page(
collection=queries,
page=page,
url=lambda page: h.url_for('search_queries.index', page=page),
item_count=total,
items_per_page=PER_PAGE
)
return render(
'search_queries/index.html', {
'queries': queries,
'pager': pager
}
)
def index(self):
page = get_page_number(tk.request.params)
total_rows = App.all_active().count()
total_pages = ((total_rows - 1) / self.paginated_by + 1) or 1
# redirect for delete page parameter reason
if not 0 < page <= total_pages:
redirect_to('apps_index')
apps_list = tk.get_action('apps_active_apps')(
data_dict={
"page": page,
"paginated_by": self.paginated_by
})
c.page = Page(collection=apps_list,
page=page,
item_count=total_rows,
items_per_page=self.paginated_by)
context = {
'apps_list': apps_list,
}
log.debug('AppsController.index context: %s', context)
return self.__render('apps_index.html', context)
def board_show(self, slug):
board = Board.get_by_slug(slug)
if not board:
abort(404)
page = get_page_number(tk.request.params)
total_rows = App.filter_board(board_slug=board.slug).count()
total_pages = (total_rows / self.paginated_by + 1) or 1
# redirect for delete page parameter reason
if not 0 < page <= total_pages:
redirect_to('apps_index')
apps_list = App.filter_board(board_slug=board.slug).offset(
(page - 1) * self.paginated_by).limit(self.paginated_by)
c.page = Page(collection=apps_list,
page=page,
item_count=total_rows,
items_per_page=self.paginated_by)
context = {
'board': board,
'apps_list': apps_list,
}
log.debug('AppController.board_show context: %s', context)
return self.__render('apps_index.html', context)
def activity(self):
do_if_user_not_sysadmin()
page = get_page_number(tk.request.params)
total_rows = Thread.all().count()
total_pages = ((total_rows - 1) / self.paginated_by + 1) or 1
if not 0 < page <= total_pages:
# redirect for delete page parameter reason
redirect_to('forum_activity')
thread_activity = Thread.all().order_by(Thread.created.desc())
post_activity = Post.all().order_by(Post.created.desc())
activity = [
dict(id=i.id,
url=i.get_absolute_url(),
ban_url=tk.url_for('forum_thread_ban', id=i.id),
type=tk._('Thread'),
content=i.content,
author_name=i.author.name,
created=i.created) for i in thread_activity
]
activity += [
dict(id=i.id,
url=i.get_absolute_url(),
ban_url=tk.url_for('forum_post_ban', id=i.id),
type=tk._('Post'),
content=i.content,
author_name=i.author.name,
created=i.created) for i in post_activity
]
activity = sorted(activity, key=itemgetter('created'), reverse=True)
start_elem = int((page - 1) * self.paginated_by)
end_elem = int(page * self.paginated_by)
c.page = Page(collection=thread_activity,
page=page,
item_count=total_rows,
items_per_page=self.paginated_by)
return self.__render('forum_activity.html',
{'activity': activity[start_elem:end_elem]})
def dashboard_datasets(self):
"""User Dashboard > My Datasets pagination."""
context = {
'for_view': True,
'user': c.user or c.author,
'auth_user_obj': c.userobj
}
data_dict = {'user_obj': c.userobj, 'include_datasets': True}
try:
user_dict = logic.get_action('user_show')(context, data_dict)
except NotFound:
abort(404, _('User not found'))
except NotAuthorized:
abort(401, _('Not authorized to see this page'))
c.user_dict = user_dict
items_per_page = g.datasets_per_page or 20 # , readme
# check ckan version and call appropriate get_page number
if p.toolkit.check_ckan_version(min_version='2.5.0',
max_version='2.5.3'):
page = self._get_page_number(request.params) or 1
else:
page = h.get_page_number(request.params) or 1
c.page = h.Page(
collection=user_dict['datasets'],
page=page,
url=h.pager_url,
item_count=len(user_dict['datasets']),
items_per_page=items_per_page,
)
c.page.items = user_dict['datasets']
return render('user/dashboard_datasets.html')
def search(self):
from ckan.lib.search import SearchError, SearchQueryError
package_type = self._guess_package_type()
try:
context = {'model': model, 'user': c.user,
'auth_user_obj': c.userobj}
check_access('site_read', context)
except NotAuthorized:
abort(403, _('Not authorized to see this page'))
# unicode format (decoded from utf8)
q = c.q = request.params.get('q', u'')
c.query_error = False
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='ckanext.sixodp_showcase.controller:Sixodp_ShowcaseController', 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='ckanext.sixodp_showcase.controller:Sixodp_ShowcaseController',
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 search_url(params, package_type)
c.sort_by = _sort_by
if not sort_by:
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 search_url(params, package_type)
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, '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 asbool(
config.get('ckan.search.show_all_types', 'False')):
fq += ' +dataset_type:dataset'
facets = OrderedDict()
default_facet_titles = {
'organization': _('Organizations'),
'groups': _('Groups'),
'tags': _('Tags'),
'res_format': _('Formats'),
'license_id': _('Licenses'),
}
for facet in h.facets():
if facet in default_facet_titles:
facets[facet] = default_facet_titles[facet]
else:
facets[facet] = facet
# Facet titles
for plugin in ckan.plugins.PluginImplementations(ckan.plugins.IFacets):
facets = plugin.dataset_facets(facets, package_type)
c.facet_titles = facets
# Set the custom default sort parameter here
# Might need a rewrite when ckan is updated
if not sort_by:
sort_by = 'metadata_created desc'
data_dict = {
'q': q,
'fq': fq.strip(),
'facet.field': facets.keys(),
'rows': limit,
'start': (page - 1) * limit,
'sort': sort_by,
'extras': search_extras,
'include_private': asbool(config.get(
'ckan.search.default_include_private', True)),
}
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 SearchQueryError, se:
# User's search parameters are invalid, in such a way that is not
# achievable with the web interface, so return a proper error to
# discourage spiders which are the main cause of this.
log.info('Dataset search query rejected: %r', se.args)
abort(400, _('Invalid search query: {error_message}')
.format(error_message=str(se)))
def list(self):
format = request.params.get("format", "")
if format == "atom":
# Generate and return Atom 1.0 document.
from webhelpers.feedgenerator import Atom1Feed
feed = Atom1Feed(
title=_(u"CKAN Repository Revision History"),
link=h.url_for(controller="revision", action="list", id=""),
description=_(u"Recent changes to the CKAN repository."),
language=unicode(get_lang()),
)
# TODO: make this configurable?
# we do not want the system to fall over!
maxresults = 200
try:
dayHorizon = int(request.params.get("days", 5))
except:
dayHorizon = 5
ourtimedelta = timedelta(days=-dayHorizon)
since_when = datetime.now() + ourtimedelta
revision_query = model.repo.history()
revision_query = revision_query.filter(model.Revision.timestamp >= since_when).filter(
model.Revision.id != None
)
revision_query = revision_query.limit(maxresults)
for revision in revision_query:
package_indications = []
revision_changes = model.repo.list_changes(revision)
resource_revisions = revision_changes[model.Resource]
package_extra_revisions = revision_changes[model.PackageExtra]
for package in revision.packages:
if not package:
# package is None sometimes - I don't know why,
# but in the meantime while that is fixed,
# avoid an exception here
continue
if package.private:
continue
number = len(package.all_revisions)
package_revision = None
count = 0
for pr in package.all_revisions:
count += 1
if pr.revision.id == revision.id:
package_revision = pr
break
if package_revision and package_revision.state == model.State.DELETED:
transition = "deleted"
elif package_revision and count == number:
transition = "created"
else:
transition = "updated"
for resource_revision in resource_revisions:
if resource_revision.package_id == package.id:
transition += ":resources"
break
for package_extra_revision in package_extra_revisions:
if package_extra_revision.package_id == package.id:
if package_extra_revision.key == "date_updated":
transition += ":date_updated"
break
indication = "%s:%s" % (package.name, transition)
package_indications.append(indication)
pkgs = u"[%s]" % " ".join(package_indications)
item_title = u"r%s " % (revision.id)
item_title += pkgs
if revision.message:
item_title += ": %s" % (revision.message or "")
item_link = h.url_for(controller="revision", action="read", id=revision.id)
item_description = _("Datasets affected: %s.\n") % pkgs
item_description += "%s" % (revision.message or "")
item_author_name = revision.author
item_pubdate = revision.timestamp
feed.add_item(
title=item_title,
link=item_link,
description=item_description,
author_name=item_author_name,
pubdate=item_pubdate,
)
feed.content_type = "application/atom+xml"
return feed.writeString("utf-8")
else:
query = model.Session.query(model.Revision)
c.page = h.Page(
collection=query, page=h.get_page_number(request.params), url=h.pager_url, items_per_page=20
)
return base.render("revision/list.html")
def search(self):
from ckan.lib.search import SearchError, SearchQueryError
# Get package type name
package_type = self._guess_package_type()[:-1]
c.package_type = package_type
# Get page content from Wordpress
# =========================================
import ckanext.dadosgovbr.helpers.wordpress as wp
wp_page_slug = 'scheming_'+package_type+'s'
c.wp_page = type('Nothing', (object,), {})
c.wp_page.content = type('Nothing', (object,), {})
c.wp_page.content.rendered = "Conteudo da pagina nao encontrado..."
try:
c.wp_page = wp.page(wp_page_slug)
except:
pass
# DEBUG
# from pprint import pprint
# pprint(c.concursos)
# Package type facets (filters)
# =========================================
package_type_facets = u'organization groups tags res_format license_id'
if(package_type == 'inventario'):
package_type_facets = u'organization situacao_base informacoes_sigilosas_base informacoes_publicas_base atualizacoes_base dados_abertos_base'
if(package_type == 'concurso'):
package_type_facets = u'organization datasets_used'
if(package_type == 'aplicativo'):
package_type_facets = u'organization groups tags res_format license_id'
try:
context = {'model': model, 'user': c.user,
'auth_user_obj': c.userobj}
check_access('site_read', context)
except NotAuthorized:
abort(403, _('Not authorized to see this page'))
# unicode format (decoded from utf8)
q = c.q = request.params.get('q', u'')
c.query_error = False
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 search_url(params, package_type)
c.sort_by = _sort_by
if not sort_by:
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 search_url(params, package_type)
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, '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 asbool(
config.get('ckan.search.show_all_types', 'False')):
fq += ' +dataset_type:dataset'
facets = OrderedDict()
default_facet_titles = {
# Default package
'organization': _('Organizations'),
'groups': _('Groups'),
'tags': _('Tags'),
'res_format': _('Formats'),
'license_id': _('Licenses'),
# Inventário package
'situacao_base': _(u'Situação da base'),
'informacoes_sigilosas_base': _(u'Base possui informações sigilosas?'),
'vocab_sim': _(u'Sim'),
'vocab_nao': _(u'Não'),
'informacoes_publicas_base': _(u'Base possui informações públicas?'),
'informacoes_publicas_base_publico': _(u'Público'),
'atualizacoes_base': _(u'PerÃodo de atualização dos dados'),
'dados_abertos_base': _(u'Exporta para dados abertos?'),
# Concurso package
'datasets_used': _(u'Dados utilizados'),
'tags': _(u'Tags'),
'date': _(u'Data de inÃcio'),
'end_date': _(u'Data final'),
'publico': _(u'Público'),
'sim': _(u'Sim'),
'nao': _(u'Não'),
}
for facet in config.get(u'search.facets', package_type_facets.split()):
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,
'include_private': asbool(config.get(
'ckan.search.default_include_private', True)),
}
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.search_facets = query['search_facets']
c.page.items = query['results']
except SearchQueryError, se:
# User's search parameters are invalid, in such a way that is not
# achievable with the web interface, so return a proper error to
# discourage spiders which are the main cause of this.
log.info('Dataset search query rejected: %r', se.args)
abort(400, _('Invalid search query: {error_message}')
.format(error_message=str(se)))
def _read(id, limit, group_type):
u''' This is common code used by both read and bulk_process'''
extra_vars = {}
context = {
u'model': model,
u'session': model.Session,
u'user': g.user,
u'schema': _db_to_form_schema(group_type=group_type),
u'for_view': True,
u'extras_as_string': True
}
q = request.params.get(u'q', u'')
# TODO: Remove
# ckan 2.9: Adding variables that were removed from c object for
# compatibility with templates in existing extensions
g.q = q
# Search within group
if g.group_dict.get(u'is_organization'):
fq = u' owner_org:"%s"' % g.group_dict.get(u'id')
else:
fq = u' groups:"%s"' % g.group_dict.get(u'name')
extra_vars["q"] = q
g.description_formatted = \
h.render_markdown(g.group_dict.get(u'description'))
context['return_query'] = True
page = h.get_page_number(request.params)
# most search operations should reset the page counter:
params_nopage = [(k, v) for k, v in request.params.items() if k != u'page']
sort_by = request.params.get(u'sort', None)
def search_url(params):
controller = lookup_group_controller(group_type)
action = u'bulk_process' if getattr(
g, u'action', u'') == u'bulk_process' else u'read'
url = h.url_for(u'.'.join([controller, action]), id=id)
params = [(k, v.encode(u'utf-8')
if isinstance(v, string_types) else str(v))
for k, v in params]
return url + u'?' + urlencode(params)
def drill_down_url(**by):
return h.add_url_param(
alternative_url=None,
controller=u'group',
action=u'read',
extras=dict(id=g.group_dict.get(u'name')),
new_params=by)
extra_vars["drill_down_url"] = drill_down_url
def remove_field(key, value=None, replace=None):
controller = lookup_group_controller(group_type)
return h.remove_url_param(
key,
value=value,
replace=replace,
controller=controller,
action=u'read',
extras=dict(id=g.group_dict.get(u'name')))
extra_vars["remove_field"] = remove_field
def pager_url(q=None, page=None):
params = list(params_nopage)
params.append((u'page', page))
return search_url(params)
try:
extra_vars["fields"] = fields = []
extra_vars["fields_grouped"] = fields_grouped = {}
search_extras = {}
for (param, value) in request.params.items():
if param not in [u'q', u'page', u'sort'] \
and len(value) and not param.startswith(u'_'):
if not param.startswith(u'ext_'):
fields.append((param, value))
q += u' %s: "%s"' % (param, value)
if param not in fields_grouped:
fields_grouped[param] = [value]
else:
fields_grouped[param].append(value)
else:
search_extras[param] = value
# TODO: Remove
# ckan 2.9: Adding variables that were removed from c object for
# compatibility with templates in existing extensions
g.fields = fields
g.fields_grouped = fields_grouped
facets = OrderedDict()
default_facet_titles = {
u'organization': _(u'Organizations'),
u'groups': _(u'Groups'),
u'tags': _(u'Tags'),
u'res_format': _(u'Formats'),
u'license_id': _(u'Licenses')
}
for facet in h.facets():
if facet in default_facet_titles:
facets[facet] = default_facet_titles[facet]
else:
facets[facet] = facet
# Facet titles
_update_facet_titles(facets, group_type)
extra_vars["facet_titles"] = facets
data_dict = {
u'q': q,
u'fq': fq,
u'include_private': True,
u'facet.field': facets.keys(),
u'rows': limit,
u'sort': sort_by,
u'start': (page - 1) * limit,
u'extras': search_extras
}
context_ = dict((k, v) for (k, v) in context.items() if k != u'schema')
query = get_action(u'package_search')(context_, data_dict)
extra_vars["page"] = h.Page(
collection=query['results'],
page=page,
url=pager_url,
item_count=query['count'],
items_per_page=limit)
# TODO: Remove
# ckan 2.9: Adding variables that were removed from c object for
# compatibility with templates in existing extensions
g.group_dict['package_count'] = query['count']
extra_vars["search_facets"] = g.search_facets = query['search_facets']
extra_vars["search_facets_limits"] = g.search_facets_limits = {}
for facet in g.search_facets.keys():
limit = int(
request.params.get(u'_%s_limit' % facet,
config.get(u'search.facets.default', 10)))
g.search_facets_limits[facet] = limit
extra_vars["page"].items = query['results']
extra_vars["sort_by_selected"] = sort_by
except search.SearchError as se:
log.error(u'Group search error: %r', se.args)
extra_vars["query_error"] = True
extra_vars["page"] = h.Page(collection=[])
# TODO: Remove
# ckan 2.9: Adding variables that were removed from c object for
# compatibility with templates in existing extensions
g.facet_titles = facets
g.page = extra_vars["page"]
extra_vars["group_type"] = group_type
_setup_template_variables(context, {u'id': id}, group_type=group_type)
return extra_vars
def index(group_type, is_organization):
extra_vars = {}
set_org(is_organization)
page = h.get_page_number(request.params) or 1
items_per_page = int(config.get(u'ckan.datasets_per_page', 20))
context = {
u'model': model,
u'session': model.Session,
u'user': g.user,
u'for_view': True,
u'with_private': False
}
try:
_check_access(u'site_read', context)
_check_access(u'group_list', context)
except NotAuthorized:
base.abort(403, _(u'Not authorized to see this page'))
q = request.params.get(u'q', u'')
sort_by = request.params.get(u'sort')
# TODO: Remove
# ckan 2.9: Adding variables that were removed from c object for
# compatibility with templates in existing extensions
g.q = q
g.sort_by_selected = sort_by
extra_vars["q"] = q
extra_vars["sort_by_selected"] = sort_by
# pass user info to context as needed to view private datasets of
# orgs correctly
if g.userobj:
context['user_id'] = g.userobj.id
context['user_is_admin'] = g.userobj.sysadmin
try:
data_dict_global_results = {
u'all_fields': False,
u'q': q,
u'sort': sort_by,
u'type': group_type or u'group',
}
global_results = _action(u'group_list')(context,
data_dict_global_results)
except ValidationError as e:
if e.error_dict and e.error_dict.get(u'message'):
msg = e.error_dict['message']
else:
msg = str(e)
h.flash_error(msg)
extra_vars["page"] = h.Page([], 0)
extra_vars["group_type"] = group_type
return base.render(_index_template(group_type), extra_vars)
data_dict_page_results = {
u'all_fields': True,
u'q': q,
u'sort': sort_by,
u'type': group_type or u'group',
u'limit': items_per_page,
u'offset': items_per_page * (page - 1),
u'include_extras': True
}
page_results = _action(u'group_list')(context, data_dict_page_results)
extra_vars["page"] = h.Page(
collection=global_results,
page=page,
url=h.pager_url,
items_per_page=items_per_page, )
extra_vars["page"].items = page_results
extra_vars["group_type"] = group_type
# TODO: Remove
# ckan 2.9: Adding variables that were removed from c object for
# compatibility with templates in existing extensions
g.page = extra_vars["page"]
return base.render(_index_template(group_type), extra_vars)
def search(package_type):
extra_vars = {}
try:
context = {
u'model': model,
u'user': g.user,
u'auth_user_obj': g.userobj
}
check_access(u'site_read', context)
except NotAuthorized:
base.abort(403, _(u'Not authorized to see this page'))
# unicode format (decoded from utf8)
extra_vars[u'q'] = q = request.args.get(u'q', u'')
extra_vars['query_error'] = False
page = h.get_page_number(request.args)
limit = int(config.get(u'ckan.datasets_per_page', 20))
# most search operations should reset the page counter:
params_nopage = [(k, v) for k, v in request.args.items() if k != u'page']
extra_vars[u'drill_down_url'] = drill_down_url
extra_vars[u'remove_field'] = partial(remove_field, package_type)
sort_by = request.args.get(u'sort', None)
params_nosort = [(k, v) for k, v in params_nopage if k != u'sort']
extra_vars[u'sort_by'] = partial(_sort_by, params_nosort, package_type)
if not sort_by:
sort_by_fields = []
else:
sort_by_fields = [field.split()[0] for field in sort_by.split(u',')]
extra_vars[u'sort_by_fields'] = sort_by_fields
pager_url = partial(_pager_url, params_nopage, package_type)
search_url_params = urlencode(_encode_params(params_nopage))
extra_vars[u'search_url_params'] = search_url_params
try:
# fields_grouped will contain a dict of params containing
# a list of values eg {u'tags':[u'tag1', u'tag2']}
extra_vars[u'fields'] = fields = []
extra_vars[u'fields_grouped'] = fields_grouped = {}
search_extras = {}
fq = u''
for (param, value) in request.args.items():
if param not in [u'q', u'page', u'sort'] \
and len(value) and not param.startswith(u'_'):
if not param.startswith(u'ext_'):
fields.append((param, value))
fq += u' %s:"%s"' % (param, value)
if param not in fields_grouped:
fields_grouped[param] = [value]
else:
fields_grouped[param].append(value)
else:
search_extras[param] = value
context = {
u'model': model,
u'session': model.Session,
u'user': g.user,
u'for_view': True,
u'auth_user_obj': 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 = config.get(u'ckan.search.show_all_types', u'dataset')
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 = asbool(search_all_type)
search_all_type = u'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 += u' +dataset_type:{type}'.format(type=package_type)
facets = OrderedDict()
default_facet_titles = {
u'organization': _(u'Organizations'),
u'groups': _(u'Groups'),
u'tags': _(u'Tags'),
u'res_format': _(u'Formats'),
u'license_id': _(u'Licenses'),
}
for facet in h.facets():
if facet in default_facet_titles:
facets[facet] = default_facet_titles[facet]
else:
facets[facet] = facet
# Facet titles
for plugin in plugins.PluginImplementations(plugins.IFacets):
facets = plugin.dataset_facets(facets, package_type)
extra_vars[u'facet_titles'] = facets
data_dict = {
u'q': q,
u'fq': fq.strip(),
u'facet.field': facets.keys(),
u'rows': limit,
u'start': (page - 1) * limit,
u'sort': sort_by,
u'extras': search_extras,
u'include_private': asbool(
config.get(u'ckan.search.default_include_private', True)
),
}
query = get_action(u'package_search')(context, data_dict)
extra_vars[u'sort_by_selected'] = query[u'sort']
extra_vars[u'page'] = h.Page(
collection=query[u'results'],
page=page,
url=pager_url,
item_count=query[u'count'],
items_per_page=limit
)
extra_vars[u'search_facets'] = query[u'search_facets']
extra_vars[u'page'].items = query[u'results']
except SearchQueryError as se:
# User's search parameters are invalid, in such a way that is not
# achievable with the web interface, so return a proper error to
# discourage spiders which are the main cause of this.
log.info(u'Dataset search query rejected: %r', se.args)
base.abort(
400,
_(u'Invalid search query: {error_message}')
.format(error_message=str(se))
)
except SearchError as se:
# May be bad input from the user, but may also be more serious like
# bad code causing a SOLR syntax error, or a problem connecting to
# SOLR
log.error(u'Dataset search error: %r', se.args)
extra_vars[u'query_error'] = True
extra_vars[u'search_facets'] = {}
extra_vars[u'page'] = h.Page(collection=[])
# FIXME: try to avoid using global variables
g.search_facets_limits = {}
for facet in extra_vars[u'search_facets'].keys():
try:
limit = int(
request.args.get(
u'_%s_limit' % facet,
int(config.get(u'search.facets.default', 10))
)
)
except ValueError:
base.abort(
400,
_(u'Parameter u"{parameter_name}" is not '
u'an integer').format(parameter_name=u'_%s_limit' % facet)
)
g.search_facets_limits[facet] = limit
_setup_template_variables(context, {}, package_type=package_type)
extra_vars[u'dataset_type'] = package_type
# TODO: remove
for key, value in extra_vars.iteritems():
setattr(g, key, value)
return base.render(
_get_pkg_template(u'search_template', package_type), extra_vars
)
def _read(self, id, limit, group_type):
''' This is common code used by both read and bulk_process'''
context = {'model': model, 'session': model.Session,
'user': c.user,
'schema': self._db_to_form_schema(group_type=group_type),
'for_view': True, 'extras_as_string': True}
q = c.q = request.params.get('q', '')
# Search within group
if c.group_dict.get('is_organization'):
q += ' owner_org:"%s"' % c.group_dict.get('id')
else:
q += ' groups:"%s"' % c.group_dict.get('name')
c.description_formatted = \
h.render_markdown(c.group_dict.get('description'))
context['return_query'] = True
page = h.get_page_number(request.params)
# most search operations should reset the page counter:
params_nopage = [(k, v) for k, v in request.params.items()
if k != 'page']
sort_by = request.params.get('sort', None)
def search_url(params):
controller = lookup_group_controller(group_type)
action = 'bulk_process' if c.action == 'bulk_process' else 'read'
url = h.url_for(controller=controller, action=action, id=id)
params = [(k, v.encode('utf-8') if isinstance(v, basestring)
else str(v)) for k, v in params]
return url + u'?' + urlencode(params)
def drill_down_url(**by):
return h.add_url_param(alternative_url=None,
controller='group', action='read',
extras=dict(id=c.group_dict.get('name')),
new_params=by)
c.drill_down_url = drill_down_url
def remove_field(key, value=None, replace=None):
controller = lookup_group_controller(group_type)
return h.remove_url_param(key, value=value, replace=replace,
controller=controller, action='read',
extras=dict(id=c.group_dict.get('name')))
c.remove_field = remove_field
def pager_url(q=None, page=None):
params = list(params_nopage)
params.append(('page', page))
return search_url(params)
try:
c.fields = []
c.fields_grouped = {}
search_extras = {}
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))
q += ' %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
facets = OrderedDict()
default_facet_titles = {'organization': _('Organizations'),
'groups': _('Groups'),
'tags': _('Tags'),
'res_format': _('Formats'),
'license_id': _('Licenses')}
for facet in h.facets():
if facet in default_facet_titles:
facets[facet] = default_facet_titles[facet]
else:
facets[facet] = facet
# Facet titles
self._update_facet_titles(facets, group_type)
c.facet_titles = facets
data_dict = {
'q': q,
'fq': '',
'include_private': True,
'facet.field': facets.keys(),
'rows': limit,
'sort': sort_by,
'start': (page - 1) * limit,
'extras': search_extras
}
context_ = dict((k, v) for (k, v) in context.items()
if k != 'schema')
query = get_action('package_search')(context_, data_dict)
c.page = h.Page(
collection=query['results'],
page=page,
url=pager_url,
item_count=query['count'],
items_per_page=limit
)
c.group_dict['package_count'] = query['count']
c.search_facets = query['search_facets']
c.search_facets_limits = {}
for facet in c.search_facets.keys():
limit = int(request.params.get('_%s_limit' % facet,
config.get('search.facets.default', 10)))
c.search_facets_limits[facet] = limit
c.page.items = query['results']
c.sort_by_selected = sort_by
except search.SearchError, se:
log.error('Group search error: %r', se.args)
c.query_error = True
c.page = h.Page(collection=[])
def _read(id, limit, group_type):
u''' This is common code used by both read and bulk_process'''
extra_vars = {}
context = {
u'model': model,
u'session': model.Session,
u'user': g.user,
u'schema': _db_to_form_schema(group_type=group_type),
u'for_view': True,
u'extras_as_string': True
}
q = request.params.get(u'q', u'')
# TODO: Remove
# ckan 2.9: Adding variables that were removed from c object for
# compatibility with templates in existing extensions
g.q = q
# Search within group
if g.group_dict.get(u'is_organization'):
fq = u' owner_org:"%s"' % g.group_dict.get(u'id')
else:
fq = u' groups:"%s"' % g.group_dict.get(u'name')
extra_vars["q"] = q
g.description_formatted = \
h.render_markdown(g.group_dict.get(u'description'))
context['return_query'] = True
page = h.get_page_number(request.params)
# most search operations should reset the page counter:
params_nopage = [(k, v) for k, v in request.params.items() if k != u'page']
sort_by = request.params.get(u'sort', None)
def search_url(params):
controller = lookup_group_controller(group_type)
action = u'bulk_process' if getattr(
g, u'action', u'') == u'bulk_process' else u'read'
url = h.url_for(u'.'.join([controller, action]), id=id)
params = [(k, v.encode(u'utf-8')
if isinstance(v, string_types) else str(v))
for k, v in params]
return url + u'?' + urlencode(params)
def drill_down_url(**by):
return h.add_url_param(
alternative_url=None,
controller=u'group',
action=u'read',
extras=dict(id=g.group_dict.get(u'name')),
new_params=by)
extra_vars["drill_down_url"] = drill_down_url
def remove_field(key, value=None, replace=None):
controller = lookup_group_controller(group_type)
return h.remove_url_param(
key,
value=value,
replace=replace,
controller=controller,
action=u'read',
extras=dict(id=g.group_dict.get(u'name')))
extra_vars["remove_field"] = remove_field
def pager_url(q=None, page=None):
params = list(params_nopage)
params.append((u'page', page))
return search_url(params)
try:
extra_vars["fields"] = fields = []
extra_vars["fields_grouped"] = fields_grouped = {}
search_extras = {}
for (param, value) in request.params.items():
if param not in [u'q', u'page', u'sort'] \
and len(value) and not param.startswith(u'_'):
if not param.startswith(u'ext_'):
fields.append((param, value))
q += u' %s: "%s"' % (param, value)
if param not in fields_grouped:
fields_grouped[param] = [value]
else:
fields_grouped[param].append(value)
else:
search_extras[param] = value
# TODO: Remove
# ckan 2.9: Adding variables that were removed from c object for
# compatibility with templates in existing extensions
g.fields = fields
g.fields_grouped = fields_grouped
facets = OrderedDict()
default_facet_titles = {
u'organization': _(u'Organizations'),
u'groups': _(u'Groups'),
u'tags': _(u'Tags'),
u'res_format': _(u'Formats'),
u'license_id': _(u'Licenses')
}
for facet in h.facets():
if facet in default_facet_titles:
facets[facet] = default_facet_titles[facet]
else:
facets[facet] = facet
# Facet titles
_update_facet_titles(facets, group_type)
extra_vars["facet_titles"] = facets
data_dict = {
u'q': q,
u'fq': fq,
u'include_private': True,
u'facet.field': facets.keys(),
u'rows': limit,
u'sort': sort_by,
u'start': (page - 1) * limit,
u'extras': search_extras
}
context_ = dict((k, v) for (k, v) in context.items() if k != u'schema')
query = get_action(u'package_search')(context_, data_dict)
extra_vars["page"] = h.Page(
collection=query['results'],
page=page,
url=pager_url,
item_count=query['count'],
items_per_page=limit)
# TODO: Remove
# ckan 2.9: Adding variables that were removed from c object for
# compatibility with templates in existing extensions
g.group_dict['package_count'] = query['count']
extra_vars["search_facets"] = g.search_facets = query['search_facets']
extra_vars["search_facets_limits"] = g.search_facets_limits = {}
for facet in g.search_facets.keys():
limit = int(
request.params.get(u'_%s_limit' % facet,
config.get(u'search.facets.default', 10)))
g.search_facets_limits[facet] = limit
extra_vars["page"].items = query['results']
extra_vars["sort_by_selected"] = sort_by
except search.SearchError as se:
log.error(u'Group search error: %r', se.args)
extra_vars["query_error"] = True
extra_vars["page"] = h.Page(collection=[])
# TODO: Remove
# ckan 2.9: Adding variables that were removed from c object for
# compatibility with templates in existing extensions
g.facet_titles = facets
g.page = extra_vars["page"]
extra_vars["group_type"] = group_type
_setup_template_variables(context, {u'id': id}, group_type=group_type)
return extra_vars
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=[])
