def package_id_exists(value, context):
model = context['model']
session = context['session']
result = session.query(model.Package).get(value)
if not result:
raise Invalid('%s: %s' % (_('Not found'), _('Dataset')))
return value
def group_id_or_name_exists(reference, context):
"""
Raises Invalid if a group identified by the name or id cannot be found.
"""
model = context['model']
result = model.Group.get(reference)
if not result:
raise Invalid(_('That group name or ID does not exist.'))
return reference
def _check_url(url):
if not url:
return
parts = urlparse.urlsplit(url)
if not parts.scheme or not parts.netloc:
if not url.startswith('www.'):
raise Invalid(
_('Incorrect web address format detected. Web address must start with http://, https:// or www.'
))
def iati_owner_org_validator(key, data, errors, context):
value = data.get(key)
model = context['model']
group = model.Group.get(value)
if not group.state == 'active':
raise Invalid('Publisher must be active to add datasets to it')
data[key] = group.id
def int_validator(value, context):
if isinstance(value, int):
return value
try:
if value.strip() == '':
return None
return int(value)
except (AttributeError, ValueError), e:
raise Invalid(_('Invalid integer'))
def iati_resource_url(value, context):
if not value:
return
try:
url = urlparse(value)
except ValueError:
raise Invalid('Invalid URL')
valid_schemes = ('http', 'https', 'ftp')
if not url.scheme in valid_schemes:
raise Invalid('Invalid URL scheme')
if not url.hostname:
raise Invalid('Invalid URL host name')
value = urlunparse(url)
return value
def usage_terms_accepted(value, context):
'''
Check if a boolean value is true
:param value: value to check
:param context: CKAN context
'''
if not asbool(value):
raise Invalid(_('Terms of use must be accepted'))
def check_langtitle(key, data, errors, context):
'''
Check that langtitle field exists
'''
if not (data.get(('langtitle', 0, 'value')) or data.get(('title', ))):
raise Invalid({
'key': 'langtitle',
'value': _('Missing dataset title')
})
def isodate(value, context):
if isinstance(value, datetime.datetime):
return value
if value == '':
return None
try:
date = h.date_str_to_datetime(value)
except (TypeError, ValueError), e:
raise Invalid(_('Date format incorrect'))
def package_id_exists(value, context):
model = context['model']
session = context['session']
result = session.query(model.Package).get(value)
if not result:
raise Invalid(_('Package was not found.'))
return value
def postprocess_dataset_for_edit(key, data, errors, context):
assert key[0] == '__after', (
'This validator can only be invoked in the __after stage')
def debug(msg):
logger.debug('Post-processing dataset for editing: %s' % (msg))
# The state we are moving to
state = data.get(('state', ), '')
# The previous state (if exists)
pkg = context.get('package')
prev_state = pkg.state if pkg else ''
requested_with_api = 'api_version' in context
is_new = not pkg
if is_new and not requested_with_api:
return # only core metadata are expected
key_prefix = dtype = data[('dataset_type', )]
if not dtype in ext_metadata.dataset_types:
raise Invalid('Unknown dataset-type: %s' % (dtype))
# 1. Build metadata object
cls = ext_metadata.class_for_metadata(dtype)
md = cls.from_converted_data(data, for_edit=True)
if not md:
return # failed to create (in resources form ?)
data[(key_prefix, )] = md
# 2. Validate as an object
if not 'skip_validation' in context:
validation_errors = md.validate(dictize_errors=True)
# Fixme Map validation_errors to errors
#assert not validation_errors
# 3. Convert fields to extras
extras_list = data[('extras', )]
extras_list.extend(({'key': k, 'value': v} for k, v in md.to_extras()))
# 4. Compute next state
if 'skip_validation' in context:
state = data[('state', )] = 'invalid'
#data[('private',)] = True
if not state:
if prev_state == 'invalid':
state = data[('state', )] = 'active'
return
def isodate(value, context):
if isinstance(value, datetime.datetime):
return value
if value == '':
return None
try:
return helpers.date_str_to_datetime(value)
except (TypeError, ValueError):
raise Invalid(_('Date format incorrect - isodate') +
": {}".format(value))
def target_groups_validator(key, data, errors, context):
"""Validates the target groups field.
At least one of the main target groups needs to be selected."""
target_groups_value = data.get(key)
if target_groups_value is missing or target_groups_value is None or target_groups_value == '':
raise Invalid(
_('At least one of the main target groups must to be selected'))
return target_groups_value
def activity_type_exists(activity_type):
"""Raises Invalid if there is no registered activity renderer for the
given activity_type. Otherwise returns the given activity_type.
"""
from ckan.logic.action.get import activity_renderers
if activity_renderers.has_key(activity_type):
return activity_type
else:
raise Invalid('%s: %s' % (_('Not found'), _('Activity type')))
def user_password_validator(key, data, errors, context):
value = data[key]
if isinstance(value, Missing):
pass # Already handeled in core
elif not isinstance(value, basestring):
raise Invalid(_('Passwords must be strings.'))
elif value == '':
pass # Already handeled in core
else:
# NZISM compliant password rules
rules = [
any(x.isupper() for x in value),
#any(x.islower() for x in value),
any(x.isdigit() for x in value),
any(x in string.punctuation for x in value)
]
if len(value) < MIN_PASSWORD_LENGTH or sum(rules) < 3:
raise Invalid(_(MIN_LEN_ERROR.format(MIN_PASSWORD_LENGTH)))
def date_validator(value, context):
""" Validator for date fields """
if isinstance(value, datetime.date):
return value
if value == '':
return None
try:
return datetime.datetime.strptime(value, "%Y-%m-%d").date()
except (TypeError, ValueError):
raise Invalid(_('Date format incorrect'))
def user_id_or_name_exists(user_id_or_name, context):
model = context['model']
session = context['session']
result = session.query(model.User).get(user_id_or_name)
if result:
return user_id_or_name
result = session.query(model.User).filter_by(name=user_id_or_name).first()
if not result:
raise Invalid('%s: %s' % (_('Not found'), _('User')))
return result.id
def package_name_exists(value, context):
model = context['model']
session = context['session']
result = session.query(model.Package).filter_by(name=value).first()
if not result:
raise Invalid(_('Dataset with name %r does not exist.') % str(value))
return value
def package_name_exists(value, context):
model = context['model']
session = context['session']
result = session.query(model.Package).filter_by(name=value).first()
if not result:
raise Invalid(_('Not found') + ': %r' % str(value))
return value
def validate_algorithm(key, data, errors, context):
'''
Matching to hash functions according to list in
http://en.wikipedia.org/wiki/List_of_hash_functions
'''
val = data.get(key)
if isinstance(val, basestring):
if not HASH_REGEX.match(val):
raise Invalid(
_('Algorithm "%s" must be alphanumeric characters '
'or symbols _-()') % (val))
def kata_tag_name_validator(value, context):
'''
Checks an individual tag for unaccepted characters
'''
tagname_match = re.compile('[\w \-.()/#+:\?\=\&]*$', re.UNICODE)
if not tagname_match.match(value):
raise Invalid(
_('Keyword "%s" must be alphanumeric '
'characters or symbols: -_.()/#+:?=&') % (value))
return value
def callable(key, data, errors, context):
v = model.Vocabulary.get(vocab)
if not v:
raise Invalid(_('Tag vocabulary "%s" does not exist') % vocab)
tags = []
for k in data.keys():
if k[0] == 'tags':
if data[k].get('vocabulary_id') == v.id:
tags.append(data[k]['name'])
data[key] = tags
def validate_profiles(profile):
if isinstance(profile, list) and len(profile) == 1:
profile = profile[0]
validation_profile_names = [p[0] for p in VALIDATION_PROFILES]
log.debug('Validate {} ({}) in profiles func {}'.format(profile, type(profile), validation_profile_names))
if profile not in validation_profile_names:
log.error('Profile {} not found in {}'.format(profile, validation_profile_names))
raise Invalid('Unknown validation profile: {0}'.format(profile))
return [unicode(profile)]
def tag_not_in_vocabulary(key, tag_dict, errors, context):
tag_name = tag_dict[('name', )]
if not tag_name:
raise Invalid(_('No tag name'))
if tag_dict.has_key(('vocabulary_id', )):
vocabulary_id = tag_dict[('vocabulary_id', )]
else:
vocabulary_id = None
model = context['model']
session = context['session']
query = session.query(model.Tag)
query = query.filter(model.Tag.vocabulary_id == vocabulary_id)
query = query.filter(model.Tag.name == tag_name)
count = query.count()
if count > 0:
raise Invalid(
_('Tag %s already belongs to vocabulary %s') %
(tag_name, vocabulary_id))
else:
return
def id_to_dict(key, data, errors, context):
from ckanext.dgu.model.schema_codelist import Schema, Codelist
for i, id_ in enumerate(data[key]):
if key == ('schema',):
obj = Schema.get(id_)
elif key == ('codelist',):
obj = Codelist.get(id_)
else:
raise NotImplementedError('Bad key: %s' % key)
if not obj:
raise Invalid('%s id does not exist: %s' % (key, id_))
data[key][i] = obj.as_dict()
def activity_type_exists(activity_type):
"""Raises Invalid if there is no registered activity renderer for the
given activity_type. Otherwise returns the given activity_type.
This just uses object_id_validators as a lookup.
very safe.
"""
if object_id_validators.has_key(activity_type):
return activity_type
else:
raise Invalid('%s: %s' % (_('Not found'), _('Activity type')))
def json_validator(value, context):
"""
Raises Invalid if the given value is not a valid
JSON string.
"""
if value == '':
return value
try:
json.loads(value)
except ValueError:
raise Invalid('Invalid JSON')
return value
def harvest_source_config_validator(key,data,errors,context):
harvester_type = data.get(('source_type',),'')
for harvester in PluginImplementations(IHarvester):
info = harvester.info()
if info['name'] == harvester_type:
if hasattr(harvester, 'validate_config'):
try:
return harvester.validate_config(data[key])
except Exception, e:
raise Invalid('Error parsing the configuration options: %s' % str(e))
else:
return data[key]
def user_id_exists(user_id, context):
"""Raises Invalid if the given user_id does not exist in the model given
in the context, otherwise returns the given user_id.
"""
model = context['model']
session = context['session']
result = session.query(model.User).get(user_id)
if not result:
raise Invalid('%s: %s' % (_('Not found'), _('User')))
return user_id
def owner_org_validator(key, data, errors, context):
value = data.get(key)
if value is missing or not value:
if not ckan.new_authz.check_config_permission(
'create_unowned_dataset'):
raise Invalid(_('A organization must be supplied'))
data.pop(key, None)
raise StopOnError
model = context['model']
group = model.Group.get(value)
if not group:
raise Invalid(_('Organization does not exist'))
group_id = group.id
user = context['user']
user = model.User.get(user)
if not (user.sysadmin or user.is_in_group(group_id)):
raise Invalid(_('You cannot add a dataset to this organization'))
data[key] = group_id
