def validate_subject_hierarchy(subject_hierarchy):
from osf.models import Subject
validated_hierarchy, raw_hierarchy = [], set(subject_hierarchy)
for subject_id in subject_hierarchy:
subject = Subject.load(subject_id)
if not subject:
raise ValidationValueError(
'Subject with id <{}> could not be found.'.format(subject_id))
if subject.parent:
continue
raw_hierarchy.remove(subject_id)
validated_hierarchy.append(subject._id)
while raw_hierarchy:
if not set(subject.children.values_list(
'_id', flat=True)) & raw_hierarchy:
raise ValidationValueError(
'Invalid subject hierarchy: {}'.format(subject_hierarchy))
else:
for child in subject.children.filter(_id__in=raw_hierarchy):
subject = child
validated_hierarchy.append(child._id)
raw_hierarchy.remove(child._id)
break
if set(validated_hierarchy) == set(subject_hierarchy):
return
else:
raise ValidationValueError(
'Invalid subject hierarchy: {}'.format(subject_hierarchy))
raise ValidationValueError(
'Unable to find root subject in {}'.format(subject_hierarchy))
def validate_year(item):
if item:
try:
int(item)
except ValueError:
raise ValidationValueError('Please enter a valid year.')
else:
if len(item) != 4:
raise ValidationValueError('Please enter a valid year.')
def validate_year(item):
if item:
try:
int(item)
except ValueError:
raise ValidationValueError('Please enter a valid year.')
else:
if isinstance(item, string_types) and len(item) != 4:
raise ValidationValueError('Please enter a valid year.')
def _validate_reports(value, *args, **kwargs):
for key, val in value.iteritems():
if not User.load(key):
raise ValidationValueError('Keys must be user IDs')
if not isinstance(val, dict):
raise ValidationTypeError('Values must be dictionaries')
if ('category' not in val or 'text' not in val or 'date' not in val or 'retracted' not in val):
raise ValidationValueError(
('Values must include `date`, `category`, ',
'`text`, `retracted` keys')
)
def validate_metadata(self, metadata, reviewer=False, required_fields=False):
"""
Validates registration_metadata field.
"""
schema = create_jsonschema_from_metaschema(self.schema,
required_fields=required_fields,
is_reviewer=reviewer)
try:
jsonschema.validate(metadata, schema)
except jsonschema.ValidationError as e:
raise ValidationValueError(e.message)
except jsonschema.SchemaError as e:
raise ValidationValueError(e.message)
return
def validate_banner_dates(banner_id, start_date, end_date):
if start_date > end_date:
raise ValidationValueError('Start date must be before end date.')
overlapping = ScheduledBanner.objects.filter(
(models.Q(start_date__gte=start_date)
& models.Q(start_date__lte=end_date))
| (models.Q(end_date__gte=start_date)
& models.Q(end_date__lte=end_date))
| (models.Q(start_date__lte=start_date)
& models.Q(end_date__gte=end_date))).exclude(id=banner_id).exists()
if overlapping:
raise ValidationValueError('Banners dates cannot be overlapping.')
def validate_title(value):
"""Validator for Node#title. Makes sure that the value exists and is not
above 200 characters.
"""
if value is None or not value.strip():
raise ValidationValueError('Title cannot be blank.')
value = strip_html(value)
if value is None or not value.strip():
raise ValidationValueError('Invalid title.')
if len(value) > 200:
raise ValidationValueError('Title cannot exceed 200 characters.')
return True
def validate_metadata(self,
metadata,
reviewer=False,
required_fields=False):
"""
Validates registration_metadata field.
"""
schema = create_jsonschema_from_metaschema(
self.schema, required_fields=required_fields, is_reviewer=reviewer)
try:
jsonschema.validate(metadata, schema)
except jsonschema.ValidationError as e:
for page in self.schema['pages']:
for question in page['questions']:
if e.relative_schema_path[0] == 'required':
raise ValidationError(
'For your registration the \'{}\' field is required'
.format(question['title']))
elif e.relative_schema_path[0] == 'additionalProperties':
raise ValidationError(
'For your registration the \'{}\' field is extraneous and not permitted in your response.'
.format(question['qid']))
elif e.relative_path[0] == question['qid']:
if 'options' in question:
raise ValidationError(
'For your registration your response to the \'{}\' field is invalid, your response must be one of the provided options.'
.format(question['title'], ), )
raise ValidationError(
'For your registration your response to the \'{}\' field is invalid.'
.format(question['title']), )
raise ValidationError(e)
except jsonschema.SchemaError as e:
raise ValidationValueError(e)
return
def __call__(self, value):
reduced_comment = self.mention_re.sub(self.link_repl, value)
if len(reduced_comment) > self.max_length + 2:
raise ValidationValueError(
'Ensure this field has no more than {} characters.'.format(self.max_length))
return True
def validate_history_item(items):
for value in items or []:
string_required(value.get('institution'))
startMonth = value.get('startMonth')
startYear = value.get('startYear')
endMonth = value.get('endMonth')
endYear = value.get('endYear')
validate_year(startYear)
validate_year(endYear)
if startYear and endYear:
if endYear < startYear:
raise ValidationValueError('End date must be later than start date.')
elif endYear == startYear:
if endMonth and startMonth and endMonth < startMonth:
raise ValidationValueError('End date must be later than start date.')
def validate_location(value):
if value is None:
return # Allow for None locations but not broken dicts
from addons.osfstorage import settings
for key in ('service', settings.WATERBUTLER_RESOURCE, 'object'):
if key not in value:
raise ValidationValueError('Location {} missing key "{}"'.format(value, key))
return True
def validate_subjects(subject_list):
"""
Asserts all subjects in subject_list are valid subjects
:param subject_list list[Subject._id] List of flattened subject ids
:return Subject queryset
"""
from osf.models import Subject
subjects = Subject.objects.filter(_id__in=subject_list)
if subjects.count() != len(subject_list):
raise ValidationValueError('Subject not found.')
return subjects
def embargo_registration(self,
user,
end_date,
for_existing_registration=False,
notify_initiator_on_complete=False):
"""Enter registration into an embargo period at end of which, it will
be made public
:param user: User initiating the embargo
:param end_date: Date when the registration should be made public
:raises: NodeStateError if Node is not a registration
:raises: PermissionsError if user is not an admin for the Node
:raises: ValidationValueError if end_date is not within time constraints
"""
if not self.has_permission(user, 'admin'):
raise PermissionsError('Only admins may embargo a registration')
if not self._is_embargo_date_valid(end_date):
if (end_date - timezone.now()) >= settings.EMBARGO_END_DATE_MIN:
raise ValidationValueError(
'Registrations can only be embargoed for up to four years.'
)
raise ValidationValueError(
'Embargo end date must be at least three days in the future.')
embargo = self._initiate_embargo(
user,
end_date,
for_existing_registration=for_existing_registration,
notify_initiator_on_complete=notify_initiator_on_complete)
self.registered_from.add_log(
action=NodeLog.EMBARGO_INITIATED,
params={
'node': self.registered_from._id,
'registration': self._id,
'embargo_id': embargo._id,
},
auth=Auth(user),
save=True,
)
if self.is_public:
self.set_privacy('private', Auth(user))
def string_required(value):
if value is None or value.strip() == '':
raise ValidationValueError('Value must not be empty.')
return True
def validate_doi(value):
# DOI must start with 10 and have a slash in it - avoided getting too complicated
if not re.match('10\\.\\S*\\/', value):
raise ValidationValueError('"{}" is not a valid DOI'.format(value))
return True
def clean(self):
if self.url and self.owner._id in self.url:
raise ValidationValueError('Circular URL')
