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')