def new_metadata(self, id, data=None, errors=None, error_summary=None):
""" Fake metadata creation. Change status to active and redirect to read. """
context = {
'model': model,
'session': model.Session,
'user': c.user or c.author,
'auth_user_obj': c.userobj
}
data_dict = get_action('package_show')(context, {'id': id})
data_dict['id'] = id
data_dict['state'] = 'active'
context['allow_state_change'] = True
get_action('package_update')(context, data_dict)
success_message = (
'<div style="display: inline-block"><p>' +
_("Dataset was saved successfully.") + '</p>' + '<p>' +
_("Fill additional info") + ':</p>' + '<p><a href="/data/' +
h.lang() + '/dataset/' + data_dict.get('name') +
'/related/new">>' + _("Add related") + '</a></p>' +
'<p><a href="/data/' + h.lang() + '/dataset/edit/' +
data_dict.get('name') + '">>' +
_("Edit or add language versions") + '</a> ' + '<a href="/data/' +
h.lang() + '/dataset/delete/' + id + '">>' + _('Delete') +
'</a></p>' + '<p><a href="/data/' + h.lang() + '/dataset/new/">' +
_('Create Dataset') + '</a></p></div>')
h.flash_success(success_message, True)
h.redirect_to(controller='package', action='read', id=id)
def build_pages_nav_main(*args):
about_menu = toolkit.asbool(config.get('ckanext.pages.about_menu', False))
group_menu = toolkit.asbool(config.get('ckanext.pages.group_menu', False))
org_menu = toolkit.asbool(
config.get('ckanext.pages.organization_menu', True))
new_args = []
for arg in args:
if arg[0] == 'home.about' and not about_menu:
continue
if arg[0] == 'organizations_index' and not org_menu:
continue
if arg[0] == 'group_index' and not group_menu:
continue
new_args.append(arg)
output = h.build_nav_main(*new_args)
# add forum link
forum_url = config.get('ckan.pages.forum.link', False)
if forum_url:
link = h.literal(u'<a href="/{}/{}">{}</a>'.format(
h.lang(), 'forum', "Forum"))
li = h.literal('<li>') + link + h.literal('</li>')
output = output + li
# do not display any private datasets in menu even for sysadmins
pages_list = toolkit.get_action('ckanext_pages_list')(None, {
'order': True,
'private': False
})
page_name = ''
if (toolkit.c.action in ('pages_show', 'blog_show')
and toolkit.c.controller
== 'ckanext.pages.controller:PagesController'):
page_name = toolkit.c.environ['routes.url'].current().split('/')[-1]
for page in pages_list:
type_ = 'blog' if page['page_type'] == 'blog' else 'pages'
name = urllib.quote(page['name'].encode('utf-8')).decode('utf-8')
title = cgi.escape(pages_page_title(h.lang(), page))
if h.lang():
link = h.literal(u'<a href="/{}/{}/{}">{}</a>'.format(
h.lang(), type_, name, title))
else:
link = h.literal(u'<a href="/{}/{}">{}</a>'.format(
type_, name, title))
if page['name'] == page_name:
li = h.literal('<li class="active">') + link + h.literal('</li>')
else:
li = h.literal('<li>') + link + h.literal('</li>')
output = output + li
return output
def _dataset_display_name(package_or_package_dict):
if type(package_or_package_dict) is dict:
title = package_or_package_dict['title']
else:
title = package_or_package_dict.title
if isinstance(title, dict):
display = title[h.lang()]
else:
display = json.loads(title)[h.lang()]
return display
def _dataset_display_name(package_or_package_dict):
if type(package_or_package_dict) is dict:
title = package_or_package_dict['title']
else:
title = package_or_package_dict.title
if isinstance(title, dict):
display = title[h.lang()]
else:
display = json.loads(title)[h.lang()]
return display
def redirect_search(self):
''' redirect to the url parameter. '''
search_filter = base.request.params.get('search_filter')
search_block_form = base.request.params.get('search_block_form')
if search_filter == 'drupal':
params = (('search_keyword', search_block_form), )
return base.redirect(
url_with_params('/' + h.lang() + '/site-search', params))
else:
params = (('q', search_block_form), ('sort',
u'metadata_modified desc'))
return base.redirect(
url_with_params('/' + h.lang() + '/catalogo', params))
def _drupal_footer(self):
lang = helpers.lang() if helpers.lang() else "fi" # Finnish as default language
try:
# Call our custom Drupal API to get footer content
hostname = config.get('ckan.site_url', '')
response = urllib2.urlopen(hostname + '/api/footer/' + lang)
return response.read().decode("utf-8")
except urllib2.HTTPError:
return ''
except:
return ''
return None
def h_translate_facet(cls, label, facet):
if facet == 'groups':
group = model.Group.get(label)
title_i18n = group.extras['title_i18n']
if isinstance(title_i18n, basestring):
title_i18n = json.loads(title_i18n)
return title_i18n[h.lang()]
elif facet == 'update_frequency':
return _(
re.sub('[A-Z]', lambda m: ' ' + m.group(0), label).title())
elif facet == 'vocab_reuse_conditions':
return cls.h_vocab_reuse_conditions_captions()[label]
elif facet == 'has_any_reuse_conditions':
if asbool(label):
return _('Restrictions set')
else:
return _('No restrictions')
elif facet == 'institution_type':
return _(label.capitalize() + ' administration')
return label
def organization_list(context, data_dict):
q = data_dict.get('q', '')
sort = data_dict.get('sort', None)
if not sort:
sort = 'title_' + core_helpers.lang() + ' asc'
kwargs = {}
kwargs['q'] = q
kwargs['limit'] = int(data_dict.get('limit', 1000))
kwargs['offset'] = int(data_dict.get('offset', 0))
kwargs['order_by'] = sort
groups = []
groups = SortOrganizationsModel.get(**kwargs).all()
action = 'organization_show'
group_list = []
for group in groups:
data_dict['id'] = group.org_id
for key in ('include_extras', 'include_tags', 'include_users',
'include_groups', 'include_followers'):
if key not in data_dict:
data_dict[key] = False
group_list.append(get_action(action)(context, data_dict))
return group_list
def get_translated_dataset_groups(datasets):
desired_lang_code = helpers.lang()
terms = sets.Set()
for dataset in datasets:
groups = dataset.get('groups')
organization = dataset.get('organization')
if groups:
terms.add(groups[0].get('title'))
if organization:
terms.add(organization.get('title'))
# Look up translations for all datasets in one db query.
translations = toolkit.get_action('term_translation_show')(
{'model': model},
{'terms': terms,
'lang_codes': (desired_lang_code)})
for dataset in datasets:
groups = dataset.get('groups')
organization = dataset.get('organization')
items = []
if groups:
items.append(groups[0])
if organization:
items.append(organization)
for item in items:
matching_translations = [translation for
translation in translations
if translation['term'] == item.get('title')
and translation['lang_code'] == desired_lang_code]
if matching_translations:
assert len(matching_translations) == 1
item['title'] = (
matching_translations[0]['term_translation'])
return datasets
def subscribe(self):
email = request.params.get('email', None)
if email and validate_email(email):
names = name_from_email(email)
success, msg_key = mailchimp_add_subscriber(
names[0], names[1], email, tags=["Mailinglist-user"])
if success:
flash_success(translate_flash_message(msg_key, lang()),
allow_html=True)
else:
flash_error(translate_flash_message(msg_key, lang()),
allow_html=True)
else:
flash_error(translate_flash_message("ERROR_NOT_VALID", lang()),
allow_html=True)
return super(NewsletterController, self).index()
def scheming_language_text(text, prefer_lang=None, _gettext=None):
"""
:param text: {lang: text} dict or text string
:param prefer_lang: choose this language version if available
Convert "language-text" to users' language by looking up
languag in dict or using gettext if not a dict
"""
if hasattr(text, 'get'):
if not text:
return ''
prefer_lang = prefer_lang or lang()
default_locale = config.get('ckan.locale_default', 'en')
try:
v = text[prefer_lang]
except KeyError:
try:
v = text[default_locale]
except KeyError:
# just give me something to display
l, v = sorted(text.items())[0]
return v
else:
if _gettext is None:
_gettext = gettext
t = _gettext(text)
if isinstance(t, str):
return t.decode('utf-8')
return t
def _fetch_drupal_content(self, identifier, language=None, fallback=True):
""" This helper fetches content from Drupal database using url alias identifier.
Return content as dictionary containing language, title, body, node_id and edit link. None if not found.
Tries to fallback to different language if fallback is True.
Not cached.
"""
if not language:
language = helpers.lang()
query = """SELECT url_alias.language, node.title, field_revision_body.body_value, node.nid from url_alias
INNER JOIN node ON node.nid = split_part(url_alias.source, '/', 2)::integer
INNER JOIN field_revision_body ON field_revision_body.entity_id = split_part(url_alias.source, '/', 2)::integer
WHERE url_alias.alias = %(identifier)s""" # noqa: E501
results = {}
for content_language, title, body, node_id in self.engine.execute(query, {'identifier': identifier}):
results[content_language] = {'language': content_language, 'title': title, 'body': body, 'node_id': node_id}
result = results.get(language, None)
if not result and fallback and results:
for fallback_language in self._language_fallback_order:
result = results.get(fallback_language)
if result:
break
if not result:
result = results.itervalues().next()
if result:
result['edit'] = urllib.quote("/%s/node/%s/edit" % (language, str(result['node_id'])))
result['body'] = literal(result['body'])
return result
def scheming_language_text(text, prefer_lang=None, _gettext=None):
"""
:param text: {lang: text} dict or text string
:param prefer_lang: choose this language version if available
Convert "language-text" to users' language by looking up
languag in dict or using gettext if not a dict
"""
if not text:
return ''
if hasattr(text, 'get'):
prefer_lang = prefer_lang or lang()
default_locale = config.get('ckan.locale_default', 'en')
try:
v = text[prefer_lang]
except KeyError:
try:
v = text[default_locale]
except KeyError:
# just give me something to display
l, v = sorted(text.items())[0]
return v
else:
if _gettext is None:
_gettext = gettext
t = _gettext(text)
if isinstance(t, str):
return t.decode('utf-8')
return t
def h_categories(self, exclude_empty=False):
categories = tk.get_action('group_list')(data_dict={
'all_fields': True,
'include_extras': True
})
categories2 = []
for c in categories:
if c['package_count'] == 0 and exclude_empty:
continue
for extra in c['extras']:
if extra['key'] == 'color':
c['color'] = extra['value']
if extra['key'] == 'title_i18n':
c['title_i18n'] = fluent_text_output_backcompat(
extra['value'])
categories2.append(c)
if c.get('title_i18n'):
c['title'] = c['title_i18n'][h.lang()]
else:
c['title'] = c['display_name ']
return categories2
def _site_logo(self, hostname, default=None):
if "avoindata" in hostname:
hostname = "avoindata"
elif "opendata" in hostname:
hostname = "opendata"
lang = helpers.lang() if helpers.lang() else "default"
dict_key = hostname + "_" + lang
logo = self.logos.get(dict_key, self.logos.get('default', None))
if logo:
return literal('<img src="%s" class="site-logo" />' % helpers.url_for_static("/images/logo/%s" % logo))
else:
return self._short_domain(hostname, default)
def get_datapreview_recombinant(dataset_type, res_id):
from ckanext.recombinant.plugins import get_table
t = get_table(dataset_type)
default_preview_args = {}
if 'default_preview_sort' in t:
default_preview_args['sort'] = t['default_preview_sort']
lc = ckanapi.LocalCKAN(username=c.user)
results = lc.action.datastore_search(
resource_id=res_id, limit=0,
**default_preview_args)
lang = h.lang()
field_label = {}
for f in t['fields']:
label = f['label'].split(' / ')
label = label[0] if lang == 'en' else label[-1]
field_label[f['datastore_id']] = label
fields = [{
'type': f['type'],
'id': f['id'],
'label': field_label.get(f['id'], f['id'])}
for f in results['fields']]
return h.snippet('package/wet_datatable.html',
resource_id=res_id,
ds_fields=fields)
def link(self):
try:
ytp_drupal = get_plugin('ytp_drupal')
if not ytp_drupal or not c.user:
raise NotFound
return "/%s/user/%s/edit" % (helpers.lang(), str(ytp_drupal.get_drupal_user_id(c.user)))
except NotFound:
return "/"
def unpack_json_or_text(value):
if isinstance(value, basestring):
try:
return json.loads(value)
except Exception:
return {h.lang(): value}
return value
def contact_information(info):
"""
produce label, value pairs from contact info
"""
try:
return json.loads(info)[h.lang()]
except Exception:
return {}
def get_date_format():
if h.lang() == 'de':
df = '%d.%m.%Y'
else:
df = '%d/%m/%Y'
print df
return df
def update_dqs(self, dqs_uuid):
"""
"""
package, context = self._get_pkg_by_dqs_uuid(dqs_uuid)
if request.method == 'POST':
bit_dqs = 0
for name, value in request.POST.items():
if not name.startswith('q-'):
continue
idx = int(name[2:])
bit_dqs |= 1 << idx
user = logic.get_action('get_site_user')({
'ignore_auth': True
}, None)
context = {'model': model, 'user': user['name']}
package = logic.get_action('package_patch')(context, {
'id': package['id'],
'bit_dqs': bit_dqs
})
allow_send_emails = asbool(
config.get('ckan.ksa_dqs_allow_emails_send', 'False'))
notif_emails = config.get('ckan.ksa_dqs_admin_emails', '').split()
if len(notif_emails) > 0 and allow_send_emails:
site_url = config.get('ckan.site_url', '')
url = site_url + '/dataset/' + package['name']
notif_names = 'admin'
subject = 'DQS Updated for {0}'.format(package.get('title'))
msg = '''The DQS for {title} dataset has been updated: {url}'''\
.format(title=package.get('title'), url=url)
try:
for email in notif_emails:
mailer.mail_recipient(notif_names, email, subject, msg)
except mailer.MailerException as e:
h.flash("Email error: {0}".format(e.message),
allow_html=False)
data = {
'id':
dqs_uuid,
'name':
'Data Quality Statement',
'format':
'PDF',
'package_id':
package['id'],
'url':
h.url_for('ksa_export_dqs', dqs_uuid=dqs_uuid, qualified=True)
}
self._resource_create(context, data)
return h.redirect_to('update_dataset_dqs', dqs_uuid=dqs_uuid)
questionnaire_data = questionnaire.data
if h.lang() == 'ar':
questionnaire_data = questionnaire_ar.data
extra_vars = {'pkg_dict': package, 'questionnaire': questionnaire_data}
return base.render('package/update_dqs.html', extra_vars=extra_vars)
def get_localized_value_for_display(value):
lang_code = lang()
if isinstance(value, dict):
return ogdch_loc_utils.get_localized_value_from_dict(value, lang_code)
try:
value = json.loads(value)
return ogdch_loc_utils.get_localized_value_from_dict(value, lang_code)
except ValueError:
return value
def link(self):
try:
ytp_drupal = get_plugin('ytp_drupal')
if not ytp_drupal or not c.user:
raise NotFound
return "/%s/user/%s/edit" % (
helpers.lang(), str(ytp_drupal.get_drupal_user_id(c.user)))
except NotFound:
return "/"
def get_maps_url(package_id=None, resource_id=None):
locale = helpers.lang()
if _maps_url:
if package_id and resource_id:
return('{0}?package={1}&resource={2}&locale={3}'.format(_maps_url, package_id, resource_id, locale))
else:
return('{0}?locale={1}'.format(_maps_url, locale))
else:
return '/'
def get_localized_newsletter_url():
current_language = lang()
newsletter_url = {
'en': None,
'de': 'https://www.bfs.admin.ch/bfs/de/home/dienstleistungen/ogd/newsmail.html', # noqa
'fr': 'https://www.bfs.admin.ch/bfs/fr/home/services/ogd/newsmail.html',
'it': 'https://www.bfs.admin.ch/bfs/it/home/servizi/ogd/newsmail.html',
}
return newsletter_url[current_language]
def add_to_dict(d, field_map):
fluent_field = d.get(field_map[0])
if fluent_field and type(fluent_field) is dict:
current_lang = lib_helpers.lang()
if fluent_field.get(current_lang):
d[field_map[1]] = fluent_field[current_lang]
else:
d[field_map[1]] = \
fluent_field[panama_helpers.get_default_locale()]
return d
def get_reg_link_body(user):
extra_vars = {
'reg_link': get_reset_link(user),
'site_title': config.get('ckan.site_title'),
'site_url': config.get('ckan.site_url') + '/' + h.lang(),
'user_name': user.name,
'tou_version': get_latest_legal_version('tou'),
'privacy_version': get_latest_legal_version('privacy')
}
return render_jinja2('emails/user_registration.txt', extra_vars)
def get_maps_url(package_id=None, resource_id=None):
locale = helpers.lang()
if _maps_url:
if package_id and resource_id:
return ('{0}?package={1}&resource={2}&locale={3}'.format(
_maps_url, package_id, resource_id, locale))
else:
return ('{0}?locale={1}'.format(_maps_url, locale))
else:
return '/'
def redirect_wp(page):
locale = helpers.lang()
if page:
# check if page includes a subpage
splitted = page.split('/')
if not locale == 'el':
splitted[0] = '{0}-{1}'.format(splitted[0], locale)
return ('/content/{0}/'.format('/'.join(splitted)))
else:
return ('/content/')
def redirect_wp(page):
locale = helpers.lang()
if page:
# check if page includes a subpage
splitted = page.split('/')
if not locale == 'el':
splitted[0] = '{0}-{1}'.format(splitted[0], locale)
return('/content/{0}/'.format('/'.join(splitted)))
else:
return('/content/')
def add_to_dict(d, field_map):
fluent_field = d.get(field_map[0])
if fluent_field and type(fluent_field) is dict:
current_lang = lib_helpers.lang()
if fluent_field.get(current_lang):
d[field_map[1]] = fluent_field[current_lang]
else:
d[field_map[1]] = \
fluent_field[panama_helpers.get_default_locale()]
return d
def _service_alerts(self):
""" Get service alerts from Drupal """
language = None if self._translations_disabled else helpers.lang()
return self.engine.execute(
"""SELECT nid, title FROM node WHERE type = %(type)s AND language = %(language)s AND status = %(status)s""",
{
'type': self._node_type,
'language': language,
'status': self._node_status
})
def get_resource_for_field_for_form(field):
lang = h.lang()
if lang == 'en':
# english is named "name" because i18n was added later.
lang = 'name'
return [{
'name': (e.get(lang, '').strip() or e['name']),
'id': e['id'],
'country_codes': e.get('country_codes', '')
} for e in get_resource_for_field(field) if e['id'] and e['name']]
def _pages_list(context, data_dict):
search = {}
if db.pages_table is None:
db.init_db(context['model'])
org_id = data_dict.get('org_id')
ordered = data_dict.get('order')
order_publish_date = data_dict.get('order_publish_date')
page_type = data_dict.get('page_type')
private = data_dict.get('private', True)
if ordered:
search['order'] = True
if page_type:
search['page_type'] = page_type
if order_publish_date:
search['order_publish_date'] = True
search['lang'] = h.lang()
if not org_id:
search['group_id'] = None
try:
p.toolkit.check_access('ckanext_pages_update', context, data_dict)
if not private:
search['private'] = False
except p.toolkit.NotAuthorized:
search['private'] = False
else:
group = context['model'].Group.get(org_id)
user = context['user']
member = authz.has_user_permission_for_group_or_org(
group.id, user, 'read')
search['group_id'] = org_id
if not member:
search['private'] = False
out = db.Page.pages(**search)
out_list = []
for pg in out:
parser = HTMLFirstImage()
parser.feed(pg.content)
img = parser.first_image
pg_row = {
'title': pg.title,
'content': pg.content,
'name': pg.name,
'publish_date':
pg.publish_date.isoformat() if pg.publish_date else None,
'group_id': pg.group_id,
'page_type': pg.page_type,
'image_url': pg.image_url
}
if img:
pg_row['image'] = img
extras = pg.extras
if extras:
pg_row.update(json.loads(pg.extras))
out_list.append(pg_row)
return out_list
def home_block_link(block='one'):
'''Helper to make the new configuraiton avialable to templates. Returns
the configuraiton or empty string for the specified home block link.
Defaults to English but returns french if language is french.
'''
value = config.get(
'ckanext.ontario_theme.home_block_{}_link-en'.format(block), '')
if h.lang() == 'fr':
value = config.get(
'ckanext.ontario_theme.home_block_{}_link-fr'.format(block), '')
return value
def new_metadata(self, id, data=None, errors=None, error_summary=None):
""" Fake metadata creation. Change status to active and redirect to read. """
context = {'model': model, 'session': model.Session,
'user': c.user or c.author, 'auth_user_obj': c.userobj}
data_dict = get_action('package_show')(context, {'id': id})
data_dict['id'] = id
data_dict['state'] = 'active'
context['allow_state_change'] = True
get_action('package_update')(context, data_dict)
success_message = ('<div style="display: inline-block"><p>' + _("Dataset was saved successfully.") + '</p>' +
'<p>' + _("Fill additional info") + ':</p>' +
'<p><a href="/data/' + h.lang() + '/dataset/' + data_dict.get('name') + '/related/new">>'
+ _("Add related") + '</a></p>' +
'<p><a href="/data/' + h.lang() + '/dataset/edit/' + data_dict.get('name') + '">>'
+ _("Edit or add language versions") + '</a> ' +
'<a href="/data/' + h.lang() + '/dataset/delete/' + id + '">>' + _('Delete') + '</a></p>' +
'<p><a href="/data/' + h.lang() + '/dataset/new/">' + _('Create Dataset') + '</a></p></div>')
h.flash_success(success_message, True)
h.redirect_to(controller='package', action='read', id=id)
def convert_to_multilingual(data):
'''Converts strings to multilingual with the current language set'''
if data:
log.debug('convert_to_multilingual: %s' % data)
if isinstance(data, basestring):
multilingual_data = {}
multilingual_data[h.lang()] = data
else:
multilingual_data = data
return multilingual_data
def get_resource_for_field_as_dict(field):
lang = h.lang()
if lang == 'en':
# english is named "name" because i18n was added later.
lang = 'name'
try:
return {
e['id']: (e.get(lang, '').strip() or e['name'])
for e in get_resource_for_field(field)
}
except KeyError as e:
log.error(field)
log.error(e)
return {}
def get_localized_value_from_language_dict(value):
"""display localized value of a language dict"""
user_language = lang()
try:
localized_value = value.get(user_language)
if localized_value:
return localized_value
locales = tk.config.get('ckan.locales_offered', None)
if locales:
for locale in locales.split(' '):
if value.get(locale):
return value.get(locale)
except Exception:
return value
def get_multilingual_data(field_name, data):
# may be in data[field_name],
# may be in data[field_name-lang], especially coming from a new submission
# may be in data['extras'] somewhere
log.debug("%s: %s" % (field_name, data))
if field_name in data:
# could be that we have a blank dictionary. If we're checking a translated field
# then we want to return the base field info if there's anything there.
value = data[field_name]
if not value and '_translated' in field_name:
base_field_name = field_name.replace('_translated', '')
log.debug('base_field_name: %s ' % base_field_name)
if base_field_name in data:
log.debug('base_field_name: %s ' %
{h.lang(): data[base_field_name]})
return {h.lang(): data[base_field_name]}
if isinstance(value, dict):
return value
return {h.lang(): value}
# check data[field_name-lang]
base = '%s-' % field_name
items = {
key[len(base):]: data[key]
for key in data.keys() if key.startswith(base)
}
if items:
return items
if 'extras' in data:
for elt in data['extras']:
if elt['key'] == field_name:
try:
return json.loads(elt['value'])
except:
return {h.lang(): elt['value']}
return {}
def get_geonetwork_link(uuid, organization, lang=None):
link_stem = ""
if organization == "suomen-ymparistokeskus":
link_stem = "http://metatieto.ymparisto.fi:8080/geoportal/catalog/search/resource/details.page?uuid={uuid}"
else:
if not lang:
try:
lang = helpers.lang()
except TypeError:
lang = "en"
link_stem = "http://www.paikkatietohakemisto.fi/geonetwork/srv/{lang}/main.home?uuid={uuid}"
return link_stem.format(lang=lang, uuid=uuid)
def get_term_translation(term):
desired_lang_code = helpers.lang()
translations = toolkit.get_action('term_translation_show')(
{'model': model},
{'terms': term,
'lang_codes': (desired_lang_code)})
matching_translations = [translation for
translation in translations
if translation['term'] == term
and translation['lang_code'] == desired_lang_code]
if matching_translations:
assert len(matching_translations) == 1
term = (
matching_translations[0]['term_translation'])
return term
def h_translate_facet(cls, label, facet):
if facet == 'groups':
group = model.Group.get(label)
title_i18n = fluent_text_output(group.extras['title_i18n'])
return title_i18n[h.lang()]
elif facet == 'vocab_reuse_conditions':
return cls.h_vocab_reuse_conditions_captions()[label]
elif facet == 'has_any_reuse_conditions':
if asbool(label):
return _('Restrictions set')
else:
return _('No restrictions')
return label
def extra_translation(values, field, markdown=False, fallback=None):
""" Used as helper. Get correct translation from extras (values) for given field.
If markdown is True uses markdown rendering for value. If markdown is number use markdown_extract with given value.
If fallback is set then use fallback as value if value is empty.
If fallback is function then call given function with `values`.
"""
lang = ""
try:
lang = helpers.lang()
except TypeError:
pass
translation = values.get('%s_%s' % (field, lang), "") or values.get(field, "") if values else ""
if not translation and fallback:
translation = fallback(values) if hasattr(fallback, '__call__') else fallback
return _markdown(translation, markdown) if markdown and translation else translation
def scheming_language_text(text, _gettext=None, _lang=None):
"""
:param text: {lang: text} dict or text string
Convert "language-text" to users' language by looking up
languag in dict or using gettext if not a dict
"""
if hasattr(text, 'get'):
if _lang is None:
_lang = lang()
v = text.get(_lang)
if not v:
v = text.get(config.get('ckan.locale_default', 'en'))
if not v:
# just give me something to display
l, v = sorted(text.items())[0]
return v
else:
if _gettext is None:
_gettext = gettext
return _gettext(text)
def h_categories(self, exclude_empty = False):
categories = tk.get_action('group_list')(data_dict={'all_fields': True, 'include_extras': True})
categories2 = []
for c in categories:
if c['package_count'] == 0 and exclude_empty:
continue
for extra in c['extras']:
if extra['key'] == 'color':
c['color'] = extra['value']
if extra['key'] == 'title_i18n':
c['title_i18n'] = fluent_text_output_backcompat(extra['value'])
categories2.append(c)
if c.get('title_i18n'):
c['title'] = c['title_i18n'][h.lang()]
else:
c['title'] = c['display_name ']
return categories2
def scheming_language_text(text, prefer_lang=None):
"""
:param text: {lang: text} dict or text string
:param prefer_lang: choose this language version if available
Convert "language-text" to users' language by looking up
languag in dict or using gettext if not a dict
"""
if not text:
return u''
if hasattr(text, 'get'):
try:
if prefer_lang is None:
prefer_lang = lang()
except:
pass # lang() call will fail when no user language available
else:
try:
return text[prefer_lang]
except KeyError:
pass
default_locale = config.get('ckan.locale_default', 'en')
try:
return text[default_locale]
except KeyError:
pass
l, v = sorted(text.items())[0]
return v
t = gettext(text)
if isinstance(t, str):
return t.decode('utf-8')
return t
def faq(self, context=None):
print h.lang()
#error_summary = errors
#vars = {'data': data, 'errors': errors, 'error_summary': error_summary}
return render('ckanext/vds/faq.html')
def _get_safe_locale():
try:
return helpers.lang()
except:
return _get_default_locale()
def legal(self, context=None):
if h.lang() == 'sk':
return render('legal/index.html')
else:
return render('legal/index_en.html')
def _service_alerts(self):
""" Get service alerts from Drupal """
language = None if self._translations_disabled else helpers.lang()
return self.engine.execute("""SELECT nid, title FROM node WHERE type = %(type)s AND
language = %(language)s AND status = %(status)s""",
{'type': self._node_type, 'language': language, 'status': self._node_status})
def licence(self, context=None):
if h.lang() == 'sk':
return render('licence/index.html')
else:
return render('licence/index_en.html')
def localized_url_for_static(link):
return h.url_for_static("{lang}/{link}".format(lang=h.lang(), link=link))
def licence_complete(self, context=None):
print h.lang()
#error_summary = errors
#vars = {'data': data, 'errors': errors, 'error_summary': error_summary}
return render('ckanext/vds/licence_complete.html')
def _get_safe_locale():
return helpers.lang()
def fluent_text_output_backcompat(value):
try:
return fluent_text_output(value)
except Exception:
return {h.lang(): value}
def _read(self, id, limit):
''' This is common code used by both read and bulk_process'''
group_type = self._get_group_type(id.split('@')[0])
context = {'model': model, 'session': model.Session,
'user': c.user or c.author,
'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')
description = c.group_dict.get('description')
if description:
if group_type == 'group':
c.description_formatted = h.render_markdown(description.get(h.lang()))
else:
c.description_formatted = h.render_markdown(description)
context['return_query'] = True
# c.group_admins is used by CKAN's legacy (Genshi) templates only,
# if we drop support for those then we can delete this line.
c.group_admins = new_authz.get_group_or_org_admin_ids(c.group.id)
page = self._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):
if group_type == 'organization':
if c.action == 'bulk_process':
url = self._url_for(controller='organization',
action='bulk_process',
id=id)
else:
url = self._url_for(controller='organization',
action='read',
id=id)
else:
url = self._url_for(controller='group', action='read', 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):
return h.remove_url_param(key, value=value, replace=replace,
controller='group', 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 = []
search_extras = {}
for (param, value) in request.params.items():
if not param 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)
else:
search_extras[param] = value
fq = 'capacity:"public"'
user_member_of_orgs = [org['id'] for org
in h.organizations_available('read')]
if (c.group and c.group.id in user_member_of_orgs):
fq = ''
context['ignore_capacity_check'] = True
facets = OrderedDict()
default_facet_titles = {'organization': _('Organizations'),
'groups': _('Groups'),
'tags': _('Tags'),
'res_format': _('Formats'),
'license_id': _('Licenses')}
for facet in g.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):
if self.group_type == 'organization':
facets = plugin.organization_facets(
facets, self.group_type, None)
else:
facets = plugin.group_facets(
facets, self.group_type, None)
if 'capacity' in facets and (self.group_type != 'organization' or
not user_member_of_orgs):
del facets['capacity']
c.facet_titles = facets
data_dict = {
'q': q,
'fq': fq,
'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.facets = query['facets']
maintain.deprecate_context_item('facets',
'Use `c.search_facets` instead.')
c.search_facets = query['search_facets']
c.search_facets_limits = {}
for facet in c.facets.keys():
limit = int(request.params.get('_%s_limit' % facet,
g.facets_default_number))
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.facets = {}
c.page = h.Page(collection=[])
def feedback_form():
locale = helpers.lang()
if locale == 'el':
return _feedback_form_el
else:
return _feedback_form_en
