def search(self, ver=None, register=None):
log.debug('search %s params: %r' % (register, request.params))
if register == 'revision':
since_time = None
if 'since_id' in request.params:
id = request.params['since_id']
if not id:
return self._finish_bad_request(
gettext(u'No revision specified'))
rev = model.Session.query(model.Revision).get(id)
if rev is None:
return self._finish_not_found(
gettext(u'There is no revision with id: %s') % id)
since_time = rev.timestamp
elif 'since_time' in request.params:
since_time_str = request.params['since_time']
try:
since_time = h.date_str_to_datetime(since_time_str)
except ValueError, inst:
return self._finish_bad_request('ValueError: %s' % inst)
else:
return self._finish_bad_request(
gettext("Missing search term ('since_id=UUID' or " +
" 'since_time=TIMESTAMP')"))
revs = model.Session.query(model.Revision).\
filter(model.Revision.timestamp > since_time)
return self._finish_ok([rev.id for rev in revs])
def search(self, ver=None, register=None):
log.debug('search %s params: %r' % (register, request.params))
if register == 'revision':
since_time = None
if 'since_id' in request.params:
id = request.params['since_id']
if not id:
return self._finish_bad_request(
gettext(u'No revision specified'))
rev = model.Session.query(model.Revision).get(id)
if rev is None:
return self._finish_not_found(
gettext(u'There is no revision with id: %s') % id)
since_time = rev.timestamp
elif 'since_time' in request.params:
since_time_str = request.params['since_time']
try:
since_time = h.date_str_to_datetime(since_time_str)
except ValueError, inst:
return self._finish_bad_request('ValueError: %s' % inst)
else:
return self._finish_bad_request(
gettext("Missing search term ('since_id=UUID' or " +
" 'since_time=TIMESTAMP')"))
revs = model.Session.query(model.Revision).\
filter(model.Revision.timestamp > since_time)
return self._finish_ok([rev.id for rev in revs])
def _wet_pager(self, *args, **kwargs):
## a custom pagination method, because CKAN doesn't expose the pagination to the templates,
## and instead hardcodes the pagination html in helpers.py
kwargs.update(
format=u"<ul class='pagination'>$link_previous ~2~ $link_next</ul>",
symbol_previous=gettext('Previous').decode('utf-8'),
symbol_next=gettext('Next').decode('utf-8'),
curpage_attr={'class': 'active'})
return super(h.Page, self).pager(*args, **kwargs)
def _wet_pager(self, *args, **kwargs):
## a custom pagination method, because CKAN doesn't expose the pagination to the templates,
## and instead hardcodes the pagination html in helpers.py
kwargs.update(
format=u"<div class='pagination pagination-centered'><ul class='menu-horizontal ckan-paginate'>$link_previous ~2~ $link_next</ul></div>",
symbol_previous=gettext('Previous').decode('utf-8'), symbol_next=gettext('Next').decode('utf-8'),
curpage_attr={'class': 'disabled_paginator'}, link_attr={'class': 'button button-small'}
)
return super(h.Page, self).pager(*args, **kwargs)
def _wet_pager(self, *args, **kwargs):
## a custom pagination method, because CKAN doesn't expose the pagination to the templates,
## and instead hardcodes the pagination html in helpers.py
kwargs.update(
format=u"<ul class='pagination'>$link_previous ~2~ $link_next</ul>",
symbol_previous=gettext('Previous').decode('utf-8'), symbol_next=gettext('Next').decode('utf-8'),
curpage_attr={'class': 'active'}
)
return super(h.Page, self).pager(*args, **kwargs)
def _wet_pager(self, *args, **kwargs):
## a custom pagination method, because CKAN doesn't expose the pagination to the templates,
## and instead hardcodes the pagination html in helpers.py
kwargs.update(
format=
u"<div class='pagination pagination-centered'><ul class='menu-horizontal ckan-paginate'>$link_previous ~2~ $link_next</ul></div>",
symbol_previous=gettext('Previous').decode('utf-8'),
symbol_next=gettext('Next').decode('utf-8'),
curpage_attr={'class': 'disabled_paginator'},
link_attr={'class': 'button button-small'})
return super(h.Page, self).pager(*args, **kwargs)
def list(self, ver=None, register=None, subregister=None, id=None):
context = {
'model': model,
'session': model.Session,
'user': c.user,
'api_version': ver
}
log.debug('listing: %s' % context)
action_map = {
'revision': 'revision_list',
'group': 'group_list',
'dataset': 'package_list',
'tag': 'tag_list',
'related': 'related_list',
'licenses': 'licence_list',
('dataset', 'relationships'): 'package_relationships_list',
('dataset', 'revisions'): 'package_revision_list',
('dataset', 'activity'): 'package_activity_list',
('group', 'activity'): 'group_activity_list',
('user', 'activity'): 'user_activity_list',
('user', 'dashboard_activity'): 'dashboard_activity_list',
('activity', 'details'): 'activity_detail_list',
}
action = self._get_action_from_map(action_map, register, subregister)
if not action:
return self._finish_bad_request(
gettext('Cannot list entity of this type: %s') % register)
try:
return self._finish_ok(action(context, {'id': id}))
except NotFound, e:
extra_msg = e.extra_msg
return self._finish_not_found(extra_msg)
def scheming_language_text_or_empty(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
language 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:
if prefer_lang in _LOCALE_ALIASES:
prefer_lang = _LOCALE_ALIASES[prefer_lang]
try:
return text[prefer_lang]
except KeyError:
return ''
t = gettext(text)
if isinstance(t, str):
return t.decode('utf-8')
return t
def list(self, ver=None, register=None, subregister=None, id=None):
context = {'model': model, 'session': model.Session,
'user': c.user, 'api_version': ver}
log.debug('listing: %s' % context)
action_map = {
'revision': 'revision_list',
'group': 'group_list',
'dataset': 'package_list',
'tag': 'tag_list',
'related': 'related_list',
'licenses': 'licence_list',
('dataset', 'relationships'): 'package_relationships_list',
('dataset', 'revisions'): 'package_revision_list',
('dataset', 'activity'): 'package_activity_list',
('group', 'activity'): 'group_activity_list',
('user', 'activity'): 'user_activity_list',
('user', 'dashboard_activity'): 'dashboard_activity_list',
('activity', 'details'): 'activity_detail_list',
}
action = self._get_action_from_map(action_map, register, subregister)
if not action:
return self._finish_bad_request(
gettext('Cannot list entity of this type: %s') % register)
try:
return self._finish_ok(action(context, {'id': id}))
except NotFound, e:
extra_msg = e.extra_msg
return self._finish_not_found(extra_msg)
def _get_search_params(cls, request_params):
if 'qjson' in request_params:
try:
qjson_param = request_params['qjson'].replace('\\\\u', '\\u')
params = h.json.loads(qjson_param, encoding='utf8')
except ValueError, e:
raise ValueError(gettext('Malformed qjson value') + ': %r' % e)
def update(self,
ver=None,
register=None,
subregister=None,
id=None,
id2=None):
action_map = {
'dataset': 'package_update_rest',
'group': 'group_update_rest',
('dataset', 'relationships'): 'package_relationship_update_rest',
}
for type in model.PackageRelationship.get_all_types():
action_map[('dataset', type)] = 'package_relationship_update_rest'
context = {
'model': model,
'session': model.Session,
'user': c.user,
'api_version': ver,
'id': id
}
log.debug('update: %s' % (context))
try:
request_data = self._get_request_data()
data_dict = {'id': id, 'id2': id2, 'rel': subregister}
data_dict.update(request_data)
except ValueError, inst:
return self._finish_bad_request(
gettext('JSON Error: %s') % str(inst))
def delete(self, ver=None, register=None, subregister=None,
id=None, id2=None):
action_map = {
'group': 'group_delete',
'dataset': 'package_delete',
'related': 'related_delete',
('dataset', 'relationships'): 'package_relationship_delete_rest',
}
for type in model.PackageRelationship.get_all_types():
action_map[('dataset', type)] = 'package_relationship_delete_rest'
context = {'model': model, 'session': model.Session, 'user': c.user,
'api_version': ver}
data_dict = {'id': id, 'id2': id2, 'rel': subregister}
log.debug('delete %s/%s/%s/%s' % (register, id, subregister, id2))
action = self._get_action_from_map(action_map, register, subregister)
if not action:
return self._finish_bad_request(
gettext('Cannot delete entity of this type: %s %s') %
(register, subregister or ''))
try:
response_data = action(context, data_dict)
return self._finish_ok(response_data)
except NotAuthorized:
return self._finish_not_authz()
except NotFound, e:
extra_msg = e.extra_msg
return self._finish_not_found(extra_msg)
def show(self, ver=None, register=None, subregister=None,
id=None, id2=None):
action_map = {
'revision': 'revision_show',
'group': 'group_show_rest',
'tag': 'tag_show_rest',
'related': 'related_show',
'dataset': 'package_show_rest',
('dataset', 'relationships'): 'package_relationships_list',
}
for type in model.PackageRelationship.get_all_types():
action_map[('dataset', type)] = 'package_relationships_list'
context = {'model': model, 'session': model.Session, 'user': c.user,
'api_version': ver}
data_dict = {'id': id, 'id2': id2, 'rel': subregister}
log.debug('show: %s' % context)
action = self._get_action_from_map(action_map, register, subregister)
if not action:
return self._finish_bad_request(
gettext('Cannot read entity of this type: %s') % register)
try:
return self._finish_ok(action(context, data_dict))
except NotFound, e:
extra_msg = e.extra_msg
return self._finish_not_found(extra_msg)
def show(self, ver=None, register=None, subregister=None, id=None, id2=None):
action_map = {
'revision': 'revision_show',
'group': 'group_show_rest',
'tag': 'tag_show_rest',
'dataset': 'package_show_rest',
('dataset', 'relationships'): 'package_relationships_list',
}
for type in model.PackageRelationship.get_all_types():
action_map[('dataset', type)] = 'package_relationships_list'
context = {'model': model, 'session': model.Session, 'user': c.user,
'api_version': ver}
data_dict = {'id': id, 'id2': id2, 'rel': subregister}
log.debug('show: %s' % context)
action = self._get_action_from_map(action_map, register, subregister)
if not action:
return self._finish_bad_request(
gettext('Cannot read entity of this type: %s') % register)
try:
return self._finish_ok(action(context, data_dict))
except NotFound, e:
extra_msg = e.extra_msg
return self._finish_not_found(extra_msg)
def delete(self, ver=None, register=None, subregister=None, id=None, id2=None):
action_map = {
'group': 'group_delete',
'dataset': 'package_delete',
('dataset', 'relationships'): 'package_relationship_delete_rest',
}
for type in model.PackageRelationship.get_all_types():
action_map[('dataset', type)] = 'package_relationship_delete_rest'
context = {'model': model, 'session': model.Session, 'user': c.user,
'api_version': ver}
data_dict = {'id': id, 'id2': id2, 'rel': subregister}
log.debug('delete %s/%s/%s/%s' % (register, id, subregister, id2))
action = self._get_action_from_map(action_map, register, subregister)
if not action:
return self._finish_bad_request(
gettext('Cannot delete entity of this type: %s %s') %\
(register, subregister or ''))
try:
response_data = action(context, data_dict)
return self._finish_ok(response_data)
except NotAuthorized:
return self._finish_not_authz()
except NotFound, e:
extra_msg = e.extra_msg
return self._finish_not_found(extra_msg)
def dge_dataset_form_value(text):
"""
: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 but. If the text
doesn't exist look for an available text
"""
if not text:
return u''
if hasattr(text, 'get'):
final_text = u''
try:
prefer_lang = lang()
except:
prefer_lang = config.get('ckan.locale_default', 'es')
else:
try:
final_text = text[prefer_lang]
except KeyError:
pass
if not final_text:
locale_order = config.get('ckan.locale_order', '').split()
for l in locale_order:
if l in text and text[l]:
final_text = text[l]
break
return final_text
t = gettext(text)
if isinstance(t, str):
return t.decode('utf-8')
return t
def _get_search_params(cls, request_params):
if 'qjson' in request_params:
try:
params = h.json.loads(request_params['qjson'], encoding='utf8')
except ValueError, e:
raise ValueError(gettext('Malformed qjson value') + ': %r'
% e)
def action(self, logic_function, ver=None):
function = get_action(logic_function)
if not function:
log.error('Can\'t find logic function: %s' % logic_function)
return self._finish_bad_request(
gettext('Action name not known: %s') % str(logic_function))
context = {'model': model, 'session': model.Session, 'user': c.user,
'api_version':ver}
model.Session()._context = context
return_dict = {'help': function.__doc__}
try:
request_data = self._get_request_data()
except ValueError, inst:
log.error('Bad request data: %s' % str(inst))
return self._finish_bad_request(
gettext('JSON Error: %s') % str(inst))
def action(self, logic_function, ver=None):
function = get_action(logic_function)
if not function:
log.error('Can\'t find logic function: %s' % logic_function)
return self._finish_bad_request(
gettext('Action name not known: %s') % str(logic_function))
context = {'model': model, 'session': model.Session, 'user': c.user,
'api_version':ver}
model.Session()._context = context
return_dict = {'help': function.__doc__}
try:
request_data = self._get_request_data()
except ValueError, inst:
log.error('Bad request data: %s' % str(inst))
return self._finish_bad_request(
gettext('JSON Error: %s') % str(inst))
def _get_search_params(cls, request_params):
if 'qjson' in request_params:
try:
qjson_param = request_params['qjson'].replace('\\\\u', '\\u')
params = h.json.loads(qjson_param, encoding='utf8')
except ValueError, e:
raise ValueError(gettext('Malformed qjson value') + ': %r'
% e)
def choices(f, choices):
out.append({
'datastore_id': f['datastore_id'],
'label': gettext(f['label']).decode('utf-8'),
'choices': [(v,
choices[v] if all_languages else
recombinant_language_text(choices[v]))
for v in sorted(choices)],
})
def choices(f, choices):
out.append({
'datastore_id': f['datastore_id'],
'label': gettext(f['label']).decode('utf-8'),
'choices': [(v,
choices[v] if all_languages else
recombinant_language_text(choices[v], prefer_lang))
for v in sorted(choices)],
})
def action(self, logic_function, ver=None):
try:
function = get_action(logic_function)
except KeyError:
log.error('Can\'t find logic function: %s' % logic_function)
return self._finish_bad_request(
gettext('Action name not known: %s') % str(logic_function))
context = {'model': model, 'session': model.Session, 'user': c.user,
'api_version': ver}
model.Session()._context = context
return_dict = {'help': function.__doc__}
try:
side_effect_free = getattr(function, 'side_effect_free', False)
request_data = self._get_request_data(try_url_params=
side_effect_free)
except ValueError, inst:
log.error('Bad request data: %s' % str(inst))
return self._finish_bad_request(
gettext('JSON Error: %s') % str(inst))
def action(self, logic_function, ver=None):
try:
function = get_action(logic_function)
except KeyError:
log.error('Can\'t find logic function: %s' % logic_function)
return self._finish_bad_request(
gettext('Action name not known: %s') % str(logic_function))
context = {'model': model, 'session': model.Session, 'user': c.user,
'api_version': ver}
model.Session()._context = context
return_dict = {'help': function.__doc__}
try:
side_effect_free = getattr(function, 'side_effect_free', False)
request_data = self._get_request_data(try_url_params=
side_effect_free)
except ValueError, inst:
log.error('Bad request data: %s' % str(inst))
return self._finish_bad_request(
gettext('JSON Error: %s') % str(inst))
def update(self, ver=None, register=None, subregister=None, id=None, id2=None):
action_map = {
'dataset': 'package_update_rest',
'group': 'group_update_rest',
('dataset', 'relationships'): 'package_relationship_update_rest',
}
for type in model.PackageRelationship.get_all_types():
action_map[('dataset', type)] = 'package_relationship_update_rest'
context = {'model': model, 'session': model.Session, 'user': c.user,
'api_version': ver, 'id': id}
log.debug('update: %s' % (context))
try:
request_data = self._get_request_data()
data_dict = {'id': id, 'id2': id2, 'rel': subregister}
data_dict.update(request_data)
except ValueError, inst:
return self._finish_bad_request(
gettext('JSON Error: %s') % str(inst))
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''
assert text != {}
if hasattr(text, 'get'):
try:
if prefer_lang is None:
prefer_lang = lang()
except TypeError:
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 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''
assert text != {}
if hasattr(text, 'get'):
try:
if prefer_lang is None:
prefer_lang = lang()
except TypeError:
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
'user': c.user,
'api_version': ver
}
model.Session()._context = context
return_dict = {'help': function.__doc__}
try:
request_data = self._get_request_data()
except ValueError, inst:
log.error('Bad request data: %s' % str(inst))
return self._finish_bad_request(
gettext('JSON Error: %s') % str(inst))
if not isinstance(request_data, dict):
# this occurs if request_data is blank
log.error('Bad request data - not dict: %r' % request_data)
return self._finish_bad_request(
gettext('Bad request data: %s') % \
'Request data JSON decoded to %r but ' \
'it needs to be a dictionary.' % request_data)
try:
result = function(context, request_data)
return_dict['success'] = True
return_dict['result'] = result
except DataError, e:
log.error('Format incorrect: %s - %s' % (e.error, request_data))
#TODO make better error message
return self._finish(400, _(u'Integrity Error') + \
': %s - %s' % (e.error, request_data))
except NotAuthorized:
return_dict['error'] = {
'__type': 'Authorization Error',
'message': _('Access denied')
def _get_search_params(cls, request_params):
if request_params.has_key('qjson'):
try:
params = h.json.loads(request_params['qjson'], encoding='utf8')
except ValueError, e:
raise ValueError, gettext('Malformed qjson value') + ': %r' % e
}
model.Session()._context = context
return_dict = {'help': function.__doc__}
try:
side_effect_free = getattr(function, 'side_effect_free', False)
request_data = self._get_request_data(
try_url_params=side_effect_free)
except ValueError, inst:
log.error('Bad request data: %s' % str(inst))
return self._finish_bad_request(
gettext('JSON Error: %s') % str(inst))
if not isinstance(request_data, dict):
# this occurs if request_data is blank
log.error('Bad request data - not dict: %r' % request_data)
return self._finish_bad_request(
gettext('Bad request data: %s') %
'Request data JSON decoded to %r but '
'it needs to be a dictionary.' % request_data)
try:
result = function(context, request_data)
return_dict['success'] = True
return_dict['result'] = result
except DataError, e:
log.error('Format incorrect: %s - %s' % (e.error, request_data))
#TODO make better error message
return self._finish(
400,
_(u'Integrity Error') + ': %s - %s' % (e.error, request_data))
except NotAuthorized:
return_dict['error'] = {
'__type': 'Authorization Error',
'api_version': ver}
model.Session()._context = context
return_dict = {'help': function.__doc__}
try:
side_effect_free = getattr(function, 'side_effect_free', False)
request_data = self._get_request_data(try_url_params=
side_effect_free)
except ValueError, inst:
log.error('Bad request data: %s' % str(inst))
return self._finish_bad_request(
gettext('JSON Error: %s') % str(inst))
if not isinstance(request_data, dict):
# this occurs if request_data is blank
log.error('Bad request data - not dict: %r' % request_data)
return self._finish_bad_request(
gettext('Bad request data: %s') %
'Request data JSON decoded to %r but '
'it needs to be a dictionary.' % request_data)
try:
result = function(context, request_data)
return_dict['success'] = True
return_dict['result'] = result
except DataError, e:
log.error('Format incorrect: %s - %s' % (e.error, request_data))
#TODO make better error message
return self._finish(400, _(u'Integrity Error') +
': %s - %s' % (e.error, request_data))
except NotAuthorized:
return_dict['error'] = {'__type': 'Authorization Error',
'message': _('Access denied')}
return_dict['success'] = False
context = {'model': model, 'session': model.Session, 'user': c.user,
'api_version':ver}
model.Session()._context = context
return_dict = {'help': function.__doc__}
try:
request_data = self._get_request_data()
except ValueError, inst:
log.error('Bad request data: %s' % str(inst))
return self._finish_bad_request(
gettext('JSON Error: %s') % str(inst))
if not isinstance(request_data, dict):
# this occurs if request_data is blank
log.error('Bad request data - not dict: %r' % request_data)
return self._finish_bad_request(
gettext('Bad request data: %s') % \
'Request data JSON decoded to %r but ' \
'it needs to be a dictionary.' % request_data)
try:
result = function(context, request_data)
return_dict['success'] = True
return_dict['result'] = result
except DataError, e:
log.error('Format incorrect: %s - %s' % (e.error, request_data))
#TODO make better error message
return self._finish(400, _(u'Integrity Error') + \
': %s - %s' % (e.error, request_data))
except NotAuthorized:
return_dict['error'] = {'__type': 'Authorization Error',
'message': _('Access denied')}
return_dict['success'] = False
def build_package_no_form(is_admin=False, user_editable_groups=None, **kwargs):
# Restrict fields
restrict = str(kwargs.get('restrict', False)).lower() not in \
('0', 'no', 'false', 0, False)
builder = package.build_package_form(user_editable_groups=user_editable_groups)
# Extra fields
builder.add_field(common.TextExtraField('external_reference'))
builder.add_field(common.DateExtraField('date_released'))
builder.add_field(common.DateExtraField('date_updated'))
builder.add_field(common.TextExtraField('update_frequency'))
builder.add_field(common.SuggestedTextExtraField('geographic_granularity', options=schema_datano.geographic_granularity_options))
builder.add_field(GeoCoverageExtraField('geographic_coverage'))
builder.add_field(common.SuggestedTextExtraField('temporal_granularity', options=schema_datano.temporal_granularity_options))
builder.add_field(common.DateRangeExtraField('temporal_coverage'))
builder.add_field(common.SuggestedTextExtraField('categories', options=schema_datano.category_options))
builder.add_field(common.CheckboxExtraField('national_statistic'))
builder.add_field(common.TextExtraField('precision'))
builder.add_field(common.SuggestedTextExtraField('department', options=schema_datano.government_depts))
builder.add_field(common.TextExtraField('agency'))
builder.add_field(common.TextExtraField('taxonomy_url'))
builder.add_field(common.TextExtraField('title_en'))
builder.add_field(common.TextExtraField('notes_en'))
builder.add_field(common.TextExtraField('external_rss'))
builder.add_field(common.TextExtraField('example_data'))
# Labels and instructions
builder.set_field_text('national_statistic', _('National Statistic'))
builder.set_field_text('external_rss', _('External RSS'), instructions=_('Link to the data owner\'s external RSS feed.'))
builder.set_field_text('title_en', _('Title EN'), instructions=_('Title in English. Translate what you wrote in the previous field to English.'))
builder.set_field_text('notes_en', _('Notes EN'), instructions=_('Description in English. Translate what you wrote in the previous field to English.'))
builder.set_field_text('date_released', _('Date released'), instructions=_('Date when data source was made available.'), hints=_('Format: DD/MM/YYYY'))
builder.set_field_text('update_frequency', _('Update frequency'), instructions=_('How often will the data be updated.'), hints=_('e.g. annually, monthly'))
builder.set_field_text('geographic_coverage', _('Geographic coverage'), instructions=_('Select geographic coverage for your data set.'))
builder.set_field_text('temporal_coverage', _('Temporal coverage'), instructions=_('Temporal coverage for the data set.'), hints=_('Format: DD/MM/YYYY'))
builder.set_field_text('author_email', _('Author email'), instructions=_('Email of the main contact for this data source.'))
builder.set_field_text('maintainer_email', _('Maintainer email'), instructions=_('Email of a person that can be contacted for questions regarding this data source.'))
builder.set_field_text('example_data', _('Data package example'), instructions=_('Example preview of the data available in this package.'))
# Options/settings
builder.set_field_option('tags', 'with_renderer', SuggestTagRenderer)
builder.set_field_option('notes_en', 'textarea', {'size':'60x15'})
builder.set_field_option('title', 'validate', required)
builder.set_field_option('notes', 'validate', required)
builder.set_field_option('example_data', 'textarea', {'size':'60x15'})
if restrict:
for field_name in ('name', 'department', 'national_statistic'):
builder.set_field_option(field_name, 'readonly', True)
# Layout
field_groups = OrderedDict([
(_('Basic information'), ['title', 'title_en', 'name', 'version',
'notes', 'notes_en', 'tags']),
(_('Details'), ['date_released', 'update_frequency',
'geographic_coverage',
'temporal_coverage',
'author', 'author_email',
'maintainer', 'maintainer_email',
'license_id',
'url', 'external_rss', 'example_data']),
(_('Resources'), ['resources']),
(_('More details'), []),
])
if is_admin:
field_groups[gettext('More details')].append('state')
builder.set_displayed_fields(field_groups)
return builder
# Strings for i18n
[_('External reference'), _('Date released'), _('Date updated'),
_('Update frequency'), _('Geographic granularity'),
_('Geographic coverage'), _('Temporal granularity'),
_('Temporal coverage'), _('Categories'), _('National Statistic'),
_('Precision'), _('Taxonomy URL'), _('Department'), _('Agency'),
_('External RSS'), _('Data package example'),
]
