def get_meta_information(self, meta_data, value):
"""
For retrieving meta values, otherwise returns {}
"""
meta = {}
for key in meta_data or {}:
if key == 'count':
show_related_counts = self.context['request'].query_params.get(
'related_counts', False)
if utils.is_truthy(show_related_counts):
meta[key] = website_utils.rapply(meta_data[key],
_url_val,
obj=value,
serializer=self.parent)
elif utils.is_falsy(show_related_counts):
continue
if not utils.is_truthy(show_related_counts):
raise InvalidQueryStringError(
detail=
"Acceptable values for the related_counts query param are 'true' or 'false'; got '{0}'"
.format(show_related_counts),
parameter='related_counts')
else:
meta[key] = website_utils.rapply(meta_data[key],
_url_val,
obj=value,
serializer=self.parent)
return meta
def get_meta_information(self, meta_data, value):
"""
For retrieving meta values, otherwise returns {}
"""
meta = {}
for key in meta_data or {}:
if key == 'count' or key == 'unread':
show_related_counts = self.context['request'].query_params.get('related_counts', False)
if self.context['request'].parser_context.get('kwargs'):
if self.context['request'].parser_context['kwargs'].get('is_embedded'):
show_related_counts = False
field_counts_requested = self.process_related_counts_parameters(show_related_counts, value)
if utils.is_truthy(show_related_counts):
meta[key] = website_utils.rapply(meta_data[key], _url_val, obj=value, serializer=self.parent)
elif utils.is_falsy(show_related_counts):
continue
elif self.field_name in field_counts_requested:
meta[key] = website_utils.rapply(meta_data[key], _url_val, obj=value, serializer=self.parent)
else:
continue
elif key == 'projects_in_common':
if not get_user_auth(self.context['request']).user:
continue
if not self.context['request'].query_params.get('show_projects_in_common', False):
continue
meta[key] = website_utils.rapply(meta_data[key], _url_val, obj=value, serializer=self.parent)
else:
meta[key] = website_utils.rapply(meta_data[key], _url_val, obj=value, serializer=self.parent)
return meta
def get_meta_information(self, meta_data, value):
"""
For retrieving meta values, otherwise returns {}
"""
meta = {}
for key in meta_data or {}:
if key == 'count' or key == 'unread':
show_related_counts = self.context['request'].query_params.get(
'related_counts', False)
field_counts_requested = self.process_related_counts_parameters(
show_related_counts, value)
if utils.is_truthy(show_related_counts):
meta[key] = website_utils.rapply(meta_data[key],
_url_val,
obj=value,
serializer=self.parent)
elif utils.is_falsy(show_related_counts):
continue
elif self.field_name in field_counts_requested:
meta[key] = website_utils.rapply(meta_data[key],
_url_val,
obj=value,
serializer=self.parent)
else:
continue
else:
meta[key] = website_utils.rapply(meta_data[key],
_url_val,
obj=value,
serializer=self.parent)
return meta
def test_rapply_preserves_args_and_kwargs(self):
def zero_if_not_check(item, check, checkFn=lambda n: n):
if check and checkFn(item):
return item
return 0
inputs = range(5)
outputs = util.rapply(inputs, zero_if_not_check, True, checkFn=lambda n: n % 2)
assert_equal(outputs, [0, 1, 0, 3, 0])
outputs = util.rapply(inputs, zero_if_not_check, False, checkFn=lambda n: n % 2)
assert_equal(outputs, [0, 0, 0, 0, 0])
def test_rapply_preserves_args_and_kwargs(self):
def zero_if_not_check(item, check, checkFn=lambda n: n):
if check and checkFn(item):
return item
return 0
inputs = range(5)
outputs = util.rapply(inputs, zero_if_not_check, True, checkFn=lambda n: n % 2)
assert_equal(outputs, [0, 1, 0, 3, 0])
outputs = util.rapply(inputs, zero_if_not_check, False, checkFn=lambda n: n % 2)
assert_equal(outputs, [0, 0, 0, 0, 0])
def test_rapply_on_set(self):
inputs = set(i for i in range(5))
add_one = lambda n: n + 1
outputs = util.rapply(inputs, add_one)
for i in inputs:
assert_in(i + 1, outputs)
assert_true(isinstance(outputs, set))
def test_rapply_on_tuple(self):
inputs = tuple(i for i in range(5))
add_one = lambda n: n + 1
outputs = util.rapply(inputs, add_one)
for i in inputs:
assert_equal(outputs[i], i + 1)
assert_equal(type(outputs), tuple)
def update_draft_registration(auth, node, draft, *args, **kwargs):
"""Update an existing draft registration
:return: serialized draft registration
:rtype: dict
:raises: HTTPError
"""
check_draft_state(draft)
data = request.get_json()
schema_data = data.get('schema_data', {})
schema_data = rapply(schema_data, strip_html)
schema_name = data.get('schema_name')
schema_version = data.get('schema_version', 1)
if schema_name:
meta_schema = get_schema_or_fail(
Q(name=schema_name, schema_version=schema_version))
existing_schema = draft.registration_schema
if (existing_schema.name, existing_schema.schema_version) != (
meta_schema.name, meta_schema.schema_version):
draft.registration_schema = meta_schema
draft.update_metadata(schema_data)
draft.save()
return serialize_draft_registration(draft, auth), http.OK
def test_rapply_on_str(self):
input = "bob"
convert = lambda s: s.upper()
outputs = util.rapply(input, convert)
assert_equal("BOB", outputs)
assert_true(isinstance(outputs, basestring))
def test_rapply_on_str(self):
input = "bob"
convert = lambda s: s.upper()
outputs = util.rapply(input, convert)
assert_equal("BOB", outputs)
assert_true(isinstance(outputs, basestring))
def test_rapply_on_tuple(self):
inputs = tuple(i for i in range(5))
add_one = lambda n: n + 1
outputs = util.rapply(inputs, add_one)
for i in inputs:
assert_equal(outputs[i], i + 1)
assert_equal(type(outputs), tuple)
def test_rapply_on_set(self):
inputs = set(i for i in range(5))
add_one = lambda n: n + 1
outputs = util.rapply(inputs, add_one)
for i in inputs:
assert_in(i + 1, outputs)
assert_true(isinstance(outputs, set))
def update_draft_registration(auth, node, draft, *args, **kwargs):
"""Update an existing draft registration
:return: serialized draft registration
:rtype: dict
:raises: HTTPError
"""
check_draft_state(draft)
data = request.get_json()
schema_data = data.get('schema_data', {})
schema_data = rapply(schema_data, strip_html)
schema_name = data.get('schema_name')
schema_version = data.get('schema_version', 1)
if schema_name:
meta_schema = get_schema_or_fail(
Q('name', 'eq', schema_name) &
Q('schema_version', 'eq', schema_version)
)
existing_schema = draft.registration_schema
if (existing_schema.name, existing_schema.schema_version) != (meta_schema.name, meta_schema.schema_version):
draft.registration_schema = meta_schema
draft.update_metadata(schema_data)
draft.save()
return serialize_draft_registration(draft, auth), http.OK
def test_rapply(self):
inputs = {
'foo': 'bar',
'baz': {
'boom': ['kapow'],
'bang': 'bam'
},
'bat': ['man']
}
outputs = util.rapply(inputs, str.upper)
assert_equal(outputs['foo'], 'bar'.upper())
assert_equal(outputs['baz']['boom'], ['kapow'.upper()])
assert_equal(outputs['baz']['bang'], 'bam'.upper())
assert_equal(outputs['bat'], ['man'.upper()])
r_assert = lambda s: assert_equal(s.upper(), s)
util.rapply(outputs, r_assert)
def test_rapply(self):
inputs = {
'foo': 'bar',
'baz': {
'boom': ['kapow'],
'bang': 'bam'
},
'bat': ['man']
}
outputs = util.rapply(inputs, str.upper)
assert_equal(outputs['foo'], 'bar'.upper())
assert_equal(outputs['baz']['boom'], ['kapow'.upper()])
assert_equal(outputs['baz']['bang'], 'bam'.upper())
assert_equal(outputs['bat'], ['man'.upper()])
r_assert = lambda s: assert_equal(s.upper(), s)
util.rapply(outputs, r_assert)
def to_representation(self, value):
"""
Returns nested dictionary in format {'links': {'self.link_type': ... }
If no meta information, self.link_type is equal to a string containing link's URL. Otherwise,
the link is represented as a links object with 'href' and 'meta' members.
"""
meta = website_utils.rapply(self.meta, _url_val, obj=value, serializer=self.parent)
return {'links': {self.link_type: {'href': value.referent.get_absolute_url(), 'meta': meta}}}
def to_representation(self, value):
"""
Returns nested dictionary in format {'links': {'self.link_type': ... }
If no meta information, self.link_type is equal to a string containing link's URL. Otherwise,
the link is represented as a links object with 'href' and 'meta' members.
"""
meta = website_utils.rapply(self.meta, _url_val, obj=value, serializer=self.parent)
return {'links': {self.link_type: {'href': value.referent.get_absolute_url(), 'meta': meta}}}
def get_meta_information(self, meta_data, value):
"""
For retrieving meta values, otherwise returns {}
"""
meta = {}
for key in meta_data or {}:
if key == 'count' or key == 'unread':
show_related_counts = self.context['request'].query_params.get('related_counts', False)
if utils.is_truthy(show_related_counts):
meta[key] = website_utils.rapply(meta_data[key], _url_val, obj=value, serializer=self.parent)
elif utils.is_falsy(show_related_counts):
continue
if not utils.is_truthy(show_related_counts):
raise InvalidQueryStringError(
detail="Acceptable values for the related_counts query param are 'true' or 'false'; got '{0}'".format(show_related_counts),
parameter='related_counts'
)
else:
meta[key] = website_utils.rapply(meta_data[key], _url_val, obj=value, serializer=self.parent)
return meta
def get_meta_information(self, meta_data, value):
"""
For retrieving meta values, otherwise returns {}
"""
meta = {}
for key in meta_data or {}:
if key == 'count' or key == 'unread':
show_related_counts = self.context['request'].query_params.get('related_counts', False)
field_counts_requested = self.process_related_counts_parameters(show_related_counts, value)
if utils.is_truthy(show_related_counts):
meta[key] = website_utils.rapply(meta_data[key], _url_val, obj=value, serializer=self.parent)
elif utils.is_falsy(show_related_counts):
continue
elif self.field_name in field_counts_requested:
meta[key] = website_utils.rapply(meta_data[key], _url_val, obj=value, serializer=self.parent)
else:
continue
else:
meta[key] = website_utils.rapply(meta_data[key], _url_val, obj=value, serializer=self.parent)
return meta
def is_valid(self, clean_html=True, **kwargs):
"""
After validation, scrub HTML from validated_data prior to saving (for create and update views)
Exclude 'type' from validated_data.
"""
ret = super(JSONAPIListSerializer, self).is_valid(**kwargs)
if clean_html is True:
self._validated_data = website_utils.rapply(self.validated_data, strip_html)
for data in self._validated_data:
data.pop('type', None)
return ret
def is_valid(self, clean_html=True, **kwargs):
"""
After validation, scrub HTML from validated_data prior to saving (for create and update views)
Exclude 'type' from validated_data.
"""
ret = super(JSONAPIListSerializer, self).is_valid(**kwargs)
if clean_html is True:
self._validated_data = website_utils.rapply(self.validated_data, strip_html)
for data in self._validated_data:
data.pop('type', None)
return ret
def is_valid(self, clean_html=True, **kwargs):
"""
After validation, scrub HTML from validated_data prior to saving (for create and update views)
Exclude 'type' and '_id' from validated_data.
"""
ret = super(JSONAPISerializer, self).is_valid(**kwargs)
if clean_html is True:
self._validated_data = website_utils.rapply(self.validated_data, strip_html)
self._validated_data.pop('type', None)
self._validated_data.pop('target_type', None)
if self.context['request'].method in utils.UPDATE_METHODS:
self._validated_data.pop('_id', None)
return ret
def is_valid(self, clean_html=True, **kwargs):
"""
After validation, scrub HTML from validated_data prior to saving (for create and update views)
Exclude 'type' and '_id' from validated_data.
"""
ret = super(JSONAPISerializer, self).is_valid(**kwargs)
if clean_html is True:
self._validated_data = website_utils.rapply(self.validated_data, strip_html)
self._validated_data.pop('type', None)
self._validated_data.pop('target_type', None)
if self.context['request'].method in utils.UPDATE_METHODS:
self._validated_data.pop('_id', None)
return ret
def test_rapply_on_list(self):
inputs = range(5)
add_one = lambda n: n + 1
outputs = util.rapply(inputs, add_one)
for i in inputs:
assert_equal(outputs[i], i + 1)
def test_rapply_on_list(self):
inputs = range(5)
add_one = lambda n: n + 1
outputs = util.rapply(inputs, add_one)
for i in inputs:
assert_equal(outputs[i], i + 1)
def sanitize_data(self):
return website_utils.rapply(self.validated_data, strip_html)
from website.util.permissions import ADMIN, READ, WRITE, CREATOR_PERMISSIONS
from website.util.rubeus import collect_addon_js
from website.project.model import has_anonymous_link, NodeUpdateError, validate_title
from website.project.forms import NewNodeForm
from website.project.metadata.utils import serialize_meta_schemas
from osf.models import AbstractNode as Node, PrivateLink, Comment
from osf.models.licenses import serialize_node_license_record
from website import settings
from website.views import find_bookmark_collection, validate_page_num
from website.views import serialize_node_summary
from website.profile import utils
from website.util.sanitize import strip_html
from website.util import rapply
r_strip_html = lambda collection: rapply(collection, strip_html)
logger = logging.getLogger(__name__)
@must_be_valid_project
@must_have_permission(WRITE)
@must_not_be_registration
def edit_node(auth, node, **kwargs):
post_data = request.json
edited_field = post_data.get('name')
value = post_data.get('value', '')
new_val = None
if edited_field == 'title':
try:
node.set_title(value, auth=auth)
except ValidationError as e:
from osf.models import AbstractNode, PrivateLink, Contributor, Node, NodeRelation
from osf.models.contributor import get_contributor_permissions
from osf.models.licenses import serialize_node_license_record
from website import settings
from website.views import find_bookmark_collection, validate_page_num
from website.views import serialize_node_summary
from website.profile import utils
from website.util.sanitize import strip_html
from website.util import rapply
from addons.mendeley.provider import MendeleyCitationsProvider
from addons.zotero.provider import ZoteroCitationsProvider
from addons.wiki.utils import serialize_wiki_widget
from addons.dataverse.utils import serialize_dataverse_widget
from addons.forward.utils import serialize_forward_widget
r_strip_html = lambda collection: rapply(collection, strip_html)
logger = logging.getLogger(__name__)
@must_be_valid_project
@must_have_permission(WRITE)
@must_not_be_registration
def edit_node(auth, node, **kwargs):
post_data = request.json
edited_field = post_data.get('name')
value = post_data.get('value', '')
new_val = None
if edited_field == 'title':
try:
node.set_title(value, auth=auth)
def sanitize_data(self):
return website_utils.rapply(self.validated_data, strip_html)
