def update(self, instance, validated_data):
assert isinstance(instance, OSFUser), 'instance must be a User'
for attr, value in validated_data.items():
if 'social' == attr:
for key, val in value.items():
# currently only profileWebsites are a list, the rest of the social key only has one value
if key == 'profileWebsites':
instance.social[key] = val
else:
if len(val) > 1:
raise InvalidModelValueError(
detail=
'{} only accept a list of one single value'.
format(key))
instance.social[key] = val[0]
else:
setattr(instance, attr, value)
try:
instance.save()
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
except ValidationError as e:
raise InvalidModelValueError(e)
return instance
def update(self, node, validated_data):
"""Update instance with the validated data. Requires
the request to be in the serializer context.
"""
assert isinstance(node, AbstractNode), 'node must be a Node'
auth = get_user_auth(self.context['request'])
# Update tags
if 'tags' in validated_data:
new_tags = set(validated_data.pop('tags', []))
node.update_tags(new_tags, auth=auth)
if validated_data:
if 'license_type' in validated_data or 'license' in validated_data:
license_details = get_license_details(node, validated_data)
validated_data['node_license'] = license_details
try:
node.update(validated_data, auth=auth)
except ValidationError as e:
raise InvalidModelValueError(detail=e.message)
except PermissionsError:
raise exceptions.PermissionDenied
except NodeUpdateError as e:
raise exceptions.ValidationError(detail=e.reason)
except NodeStateError as e:
raise InvalidModelValueError(detail=e.message)
return node
def update(self, instance, validated_data):
assert isinstance(instance, OSFUser), 'instance must be a User'
for attr, value in validated_data.items():
if 'social' == attr:
for key, val in value.items():
instance.social[key] = val
elif 'accepted_terms_of_service' == attr:
if value and not instance.accepted_terms_of_service:
instance.accepted_terms_of_service = timezone.now()
elif 'region_id' == attr:
region_id = validated_data.get('region_id')
user_settings = instance._settings_model(
'osfstorage').objects.get(owner=instance)
user_settings.default_region_id = region_id
user_settings.save()
instance.default_region = self.context['request'].data[
'default_region']
else:
setattr(instance, attr, value)
try:
instance.save()
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
except ValidationError as e:
raise InvalidModelValueError(e)
return instance
def update(self, node, validated_data):
"""Update instance with the validated data. Requires
the request to be in the serializer context.
"""
assert isinstance(node, Node), 'node must be a Node'
auth = get_user_auth(self.context['request'])
old_tags = set([tag._id for tag in node.tags])
if 'tags' in validated_data:
current_tags = set(validated_data.pop('tags', []))
elif self.partial:
current_tags = set(old_tags)
else:
current_tags = set()
for new_tag in (current_tags - old_tags):
node.add_tag(new_tag, auth=auth)
for deleted_tag in (old_tags - current_tags):
node.remove_tag(deleted_tag, auth=auth)
if validated_data:
try:
node.update(validated_data, auth=auth)
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
except PermissionsError:
raise exceptions.PermissionDenied
except NodeUpdateError as e:
raise exceptions.ValidationError(detail=e.reason)
except NodeStateError as e:
raise InvalidModelValueError(detail=e.message)
return node
def update(self, instance, validated_data):
assert isinstance(instance, OSFUser), 'instance must be a User'
for attr, value in validated_data.items():
if 'social' == attr:
for key, val in value.items():
instance.social[key] = val
elif 'accepted_terms_of_service' == attr:
if value and not instance.accepted_terms_of_service:
instance.accepted_terms_of_service = timezone.now()
elif 'region_id' == attr:
region_id = validated_data.get('region_id')
user_settings = instance._settings_model(
'osfstorage').objects.get(owner=instance)
user_settings.default_region_id = region_id
user_settings.save()
instance.default_region = self.context['request'].data[
'default_region']
else:
setattr(instance, attr, value)
try:
instance.save()
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
except ValidationError as e:
raise InvalidModelValueError(e)
if set(validated_data.keys()).intersection(
set(OSFUser.SPAM_USER_PROFILE_FIELDS.keys())):
request_headers = string_type_request_headers(
self.context['request'])
instance.check_spam(saved_fields=validated_data,
request_headers=request_headers)
return instance
def validate_user_json(value, json_schema):
try:
jsonschema.validate(value, from_json(json_schema))
except jsonschema.ValidationError as e:
if len(e.path) > 1:
raise InvalidModelValueError("For '{}' the field value {}".format(e.path[-1], e.message))
raise InvalidModelValueError(e.message)
except jsonschema.SchemaError as e:
raise InvalidModelValueError(e.message)
validate_dates(value)
def update(self, collection, validated_data):
"""Update instance with the validated data.
"""
assert isinstance(collection, Collection), 'collection must be a Collection'
if validated_data:
for key, value in validated_data.items():
if key == 'title' and collection.is_bookmark_collection:
raise InvalidModelValueError('Bookmark collections cannot be renamed.')
setattr(collection, key, value)
try:
collection.save()
except ValidationError as e:
raise InvalidModelValueError(detail=e.messages[0])
return collection
def get_target_type(self, obj):
if not getattr(obj.referent, 'target_type', None):
raise InvalidModelValueError(
source={'pointer': '/data/relationships/target/links/related/meta/type'},
detail='Invalid comment target type.',
)
return obj.referent.target_type
def create(self, validated_data):
subjects = validated_data.pop('subjects', None)
collection = validated_data.pop('collection', None)
creator = validated_data.pop('creator', None)
guid = validated_data.pop('guid')
if not collection:
raise exceptions.ValidationError('"collection" must be specified.')
if not creator:
raise exceptions.ValidationError('"creator" must be specified.')
if not (creator.has_perm('write_collection', collection) or
(hasattr(guid.referent, 'has_permission')
and guid.referent.has_permission(creator, WRITE))):
raise exceptions.PermissionDenied(
'Must have write permission on either collection or collected object to collect.'
)
try:
obj = collection.collect_object(guid.referent, creator,
**validated_data)
except ValidationError as e:
raise InvalidModelValueError(e.message)
if subjects:
auth = get_user_auth(self.context['request'])
try:
obj.set_subjects(subjects, auth)
except PermissionsError as e:
raise exceptions.PermissionDenied(detail=str(e))
except (ValueError, NodeStateError) as e:
raise exceptions.ValidationError(detail=str(e))
return obj
def create(self, validated_data):
group = self.context['group']
user = self.get_user_object(validated_data.get('_id', None), group)
auth = Auth(self.context['request'].user)
full_name = validated_data.get('full_name', None)
email = validated_data.get('email', None)
role = self.get_group_role(validated_data, MEMBER)
try:
if user:
self.get_member_method(group, role)(user, auth)
else:
if not full_name or not email:
raise exceptions.ValidationError(
detail=
'You must provide a full_name/email combination to add an unconfirmed member.'
)
else:
user = group.add_unregistered_member(
full_name, email, auth, role)
except ValueError as e:
raise exceptions.ValidationError(detail=str(e))
except ValidationError as e:
raise InvalidModelValueError(detail=list(e)[0])
return user
def update(self, draft, validated_data):
draft = super(DraftRegistrationDetailSerializer, self).update(draft, validated_data)
user = self.context['request'].user
auth = get_user_auth(self.context['request'])
if 'tags' in validated_data:
new_tags = set(validated_data.pop('tags', []))
draft.update_tags(new_tags, auth=auth)
if 'license_type' in validated_data or 'license' in validated_data:
license_details = get_license_details(draft, validated_data)
validated_data['node_license'] = license_details
if 'affiliated_institutions' in validated_data:
institutions_list = validated_data.pop('affiliated_institutions')
new_institutions = [{'_id': institution} for institution in institutions_list]
update_institutions(draft, new_institutions, user)
if 'subjects' in validated_data:
subjects = validated_data.pop('subjects', None)
self.update_subjects(draft, subjects, auth)
try:
draft.update(validated_data, auth=auth)
except PermissionsError:
raise exceptions.PermissionDenied
except DraftRegistrationStateError as e:
raise InvalidModelValueError(detail=str(e))
return draft
def update(self, node, validated_data):
"""Update instance with the validated data. Requires
the request to be in the serializer context.
"""
assert isinstance(node, Node), 'node must be a Node'
auth = self.get_user_auth(self.context['request'])
tags = validated_data.get('tags')
if tags is not None:
del validated_data['tags']
current_tags = set(tags)
else:
current_tags = set()
old_tags = set([tag._id for tag in node.tags])
for new_tag in (current_tags - old_tags):
node.add_tag(new_tag, auth=auth)
for deleted_tag in (old_tags - current_tags):
node.remove_tag(deleted_tag, auth=auth)
if validated_data:
try:
node.update(validated_data, auth=auth)
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
except PermissionsError:
raise exceptions.PermissionDenied
return node
def create(self, validated_data):
node = Node(**validated_data)
try:
node.save()
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
return node
def validate_social(self, value):
schema = from_json('social-schema.json')
try:
jsonschema.validate(value, schema)
except jsonschema.ValidationError as e:
raise InvalidModelValueError(e)
return value
def create(self, validated_data):
request = self.context['request']
user = request.user
collection = self.context['view'].get_collection()
target_node_id = validated_data['_id']
pointer_node = AbstractNode.load(target_node_id)
if not pointer_node:
raise InvalidModelValueError(
source={'pointer': '/data/relationships/node_links/data/id'},
detail='Target Node \'{}\' not found.'.format(target_node_id))
try:
pointer = collection.collect_object(pointer_node, user)
except ValidationError:
raise InvalidModelValueError(
source={'pointer': '/data/relationships/node_links/data/id'},
detail='Target Node \'{}\' already pointed to by \'{}\'.'.
format(target_node_id, collection._id))
return pointer
def create(self, validated_data):
Alert = apps.get_model('osf.DismissedAlert')
alert = Alert(**validated_data)
try:
alert.save()
except ValidationError as e:
raise InvalidModelValueError(detail=e.messages[0])
return alert
def create(self, validated_data):
request = self.context['request']
user = request.user
Node = apps.get_model('osf.Node')
tag_instances = []
if 'tags' in validated_data:
tags = validated_data.pop('tags')
for tag in tags:
tag_instance, created = Tag.objects.get_or_create(
name=tag, defaults=dict(system=False))
tag_instances.append(tag_instance)
if 'template_from' in validated_data:
template_from = validated_data.pop('template_from')
template_node = Node.load(template_from)
if template_node is None:
raise exceptions.NotFound
if not template_node.has_permission(
user, 'read', check_parent=False):
raise exceptions.PermissionDenied
validated_data.pop('creator')
changed_data = {template_from: validated_data}
node = template_node.use_as_template(auth=get_user_auth(request),
changes=changed_data)
else:
node = Node(**validated_data)
try:
node.save()
except ValidationError as e:
raise InvalidModelValueError(detail=e.messages[0])
if len(tag_instances):
for tag in tag_instances:
node.tags.add(tag)
if is_truthy(request.GET.get('inherit_contributors')
) and validated_data['parent'].has_permission(
user, 'write'):
auth = get_user_auth(request)
parent = validated_data['parent']
contributors = []
for contributor in parent.contributor_set.exclude(user=user):
contributors.append({
'user':
contributor.user,
'permissions':
parent.get_permissions(contributor.user),
'visible':
contributor.visible
})
if not contributor.user.is_registered:
node.add_unregistered_contributor(
fullname=contributor.user.fullname,
email=contributor.user.email,
auth=auth,
permissions=parent.get_permissions(contributor.user),
existing_user=contributor.user)
node.add_contributors(contributors, auth=auth, log=True, save=True)
return node
def create(self, validated_data):
node = Node(**validated_data)
node.is_folder = True
node.category = ''
try:
node.save()
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
return node
def get_target_type(self, obj):
if isinstance(obj, Node):
return 'nodes'
elif isinstance(obj, Comment):
return 'comments'
else:
raise InvalidModelValueError(
source={'pointer': '/data/relationships/target/links/related/meta/type'},
detail='Invalid comment target type.'
)
def create(self, validated_data):
request = self.context['request']
user = request.user
auth = Auth(user)
node = self.context['view'].get_node()
target_node_id = validated_data['_id']
pointer_node = Node.load(target_node_id)
if not pointer_node or pointer_node.is_collection:
raise InvalidModelValueError(
source={'pointer': '/data/relationships/node_links/data/id'},
detail='Target Node \'{}\' not found.'.format(target_node_id))
try:
pointer = node.add_pointer(pointer_node, auth, save=True)
return pointer
except ValueError:
raise InvalidModelValueError(
source={'pointer': '/data/relationships/node_links/data/id'},
detail='Target Node \'{}\' already pointed to by \'{}\'.'.
format(target_node_id, node._id))
def update(self, instance, validated_data):
assert isinstance(instance, OSFUser), 'instance must be a User'
for attr, value in validated_data.items():
if 'social' == attr:
for key, val in value.items():
instance.social[key] = val
elif 'accepted_terms_of_service' == attr:
if value and not instance.accepted_terms_of_service:
instance.accepted_terms_of_service = timezone.now()
else:
setattr(instance, attr, value)
try:
instance.save()
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
except ValidationError as e:
raise InvalidModelValueError(e)
return instance
def create(self, validated_data):
node = Collection(**validated_data)
node.category = ''
try:
node.save()
except ValidationError as e:
raise InvalidModelValueError(detail=e.messages[0])
except IntegrityError:
raise ser.ValidationError('Each user cannot have more than one Bookmark collection.')
return node
def create(self, validated_data):
node = Node(**validated_data)
node.is_collection = True
node.category = ''
try:
node.save()
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
except NodeStateError:
raise ser.ValidationError('Each user cannot have more than one Bookmark collection.')
return node
def create(self, validated_data):
request = self.context['request']
user = request.user
if 'template_from' in validated_data:
template_from = validated_data.pop('template_from')
template_node = Node.load(key=template_from)
if template_node is None:
raise exceptions.NotFound
if not template_node.has_permission(
user, 'read', check_parent=False):
raise exceptions.PermissionDenied
validated_data.pop('creator')
changed_data = {template_from: validated_data}
node = template_node.use_as_template(auth=get_user_auth(request),
changes=changed_data)
else:
node = Node(**validated_data)
try:
node.save()
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
if is_truthy(request.GET.get('inherit_contributors')
) and validated_data['parent'].has_permission(
user, 'write'):
auth = get_user_auth(request)
parent = validated_data['parent']
contributors = []
for contributor in parent.contributors:
if contributor is not user:
contributors.append({
'user':
contributor,
'permissions':
parent.get_permissions(contributor),
'visible':
parent.get_visible(contributor)
})
if not contributor.is_registered:
node.add_unregistered_contributor(
fullname=contributor.fullname,
email=contributor.email,
auth=auth,
permissions=parent.get_permissions(contributor),
existing_user=contributor)
node.add_contributors(contributors,
auth=auth,
log=True,
save=True)
return node
def validate_dates(info):
for history in info:
if history.get('startYear'):
startDate = datetime.date(history['startYear'], history.get('startMonth', 1), 1)
if not history['ongoing']:
if history.get('endYear'):
endDate = datetime.date(history['endYear'], history.get('endMonth', 1), 1)
if history.get('startYear') and history.get('endYear'):
if (endDate - startDate).days <= 0:
raise InvalidModelValueError(detail='End date must be greater than or equal to the start date.')
def create(self, validated_data):
node = validated_data.pop('node')
fork_title = validated_data.pop('title', None)
request = self.context['request']
auth = get_user_auth(request)
fork = node.fork_node(auth, title=fork_title)
try:
fork.save()
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
return fork
def update(self, instance, validated_data):
assert isinstance(instance, User), 'instance must be a User'
for attr, value in validated_data.items():
if 'social' == attr:
for key, val in value.items():
instance.social[key] = val
else:
setattr(instance, attr, value)
try:
instance.save()
except ValidationValueError as e:
raise InvalidModelValueError(detail=e.message)
return instance
def update(self, node, validated_data):
"""Update instance with the validated data. Requires
the request to be in the serializer context.
"""
assert isinstance(node, AbstractNode), 'node must be a Node'
auth = get_user_auth(self.context['request'])
old_tags = set(node.tags.values_list('name', flat=True))
if 'tags' in validated_data:
current_tags = set(validated_data.pop('tags', []))
elif self.partial:
current_tags = set(old_tags)
else:
current_tags = set()
for new_tag in (current_tags - old_tags):
node.add_tag(new_tag, auth=auth)
for deleted_tag in (old_tags - current_tags):
node.remove_tag(deleted_tag, auth=auth)
if validated_data:
if 'license_type' in validated_data or 'license' in validated_data:
license_details = get_license_details(node, validated_data)
validated_data['node_license'] = license_details
try:
node.update(validated_data, auth=auth)
except ValidationError as e:
raise InvalidModelValueError(detail=e.message)
except PermissionsError:
raise exceptions.PermissionDenied
except NodeUpdateError as e:
raise exceptions.ValidationError(detail=e.reason)
except NodeStateError as e:
raise InvalidModelValueError(detail=e.message)
return node
def update(self, registration, validated_data):
user = self.context['request'].user
auth = Auth(user)
self.check_perms(registration, user, validated_data)
validated_data.pop('_id', None)
if 'tags' in validated_data:
self.update_registration_tags(registration, validated_data, auth)
if 'custom_citation' in validated_data:
registration.update_custom_citation(
validated_data.pop('custom_citation'), auth)
if 'license_type' in validated_data or 'license' in validated_data:
license_details = get_license_details(registration, validated_data)
validated_data['node_license'] = license_details
validated_data.pop('license_type', None)
validated_data.pop('license', None)
if 'affiliated_institutions' in validated_data:
institutions_list = validated_data.pop('affiliated_institutions')
new_institutions = [{
'_id': institution
} for institution in institutions_list]
update_institutions(registration, new_institutions, user)
registration.save()
if 'subjects' in validated_data:
subjects = validated_data.pop('subjects', None)
self.update_subjects(registration, subjects, auth)
if 'withdrawal_justification' in validated_data or 'is_pending_retraction' in validated_data:
self.retract_registration(registration, validated_data, user)
if 'is_public' in validated_data:
if validated_data.get('is_public') is False:
raise exceptions.ValidationError(
'Registrations can only be turned from private to public.')
if 'provider_specific_metadata' in validated_data:
try:
registration.update_provider_specific_metadata(
validated_data.pop('provider_specific_metadata'), )
except ValueError as e:
raise exceptions.ValidationError(str(e))
try:
registration.update(validated_data, auth=auth)
except ValidationError as e:
raise InvalidModelValueError(detail=e.messages[0])
except NodeUpdateError as err:
raise exceptions.ValidationError(err.reason)
except NodeStateError as err:
raise exceptions.ValidationError(str(err))
return registration
def validate_metadata(self, value):
schema = from_json(self.instance.serializer.osf_schema)
try:
jsonschema.validate(value, schema)
except jsonschema.ValidationError as e:
if e.relative_schema_path[0] == 'additionalProperties':
error_message = e.message
else:
error_message = 'Your response of {} for the field {} was invalid.'.format(
e.instance,
e.absolute_path[0],
)
raise InvalidModelValueError(detail=error_message,
meta={'metadata_schema': schema})
return value
