def node_register_template_page(auth, node, metaschema_id, **kwargs):
if node.is_registration and bool(node.registered_schema):
try:
meta_schema = MetaSchema.objects.get(_id=metaschema_id)
except MetaSchema.DoesNotExist:
# backwards compatability for old urls, lookup by name
meta_schema = MetaSchema.objects.filter(name=_id_to_name(metaschema_id)).order_by('-schema_version').first()
if not meta_schema:
raise HTTPError(http.NOT_FOUND, data={
'message_short': 'Invalid schema name',
'message_long': 'No registration schema with that name could be found.'
})
if not node.registered_schema.filter(id=meta_schema.id).exists():
raise HTTPError(http.BAD_REQUEST, data={
'message_short': 'Invalid schema',
'message_long': 'This registration has no registration supplment with that name.'
})
ret = _view_project(node, auth, primary=True)
my_meta = serialize_meta_schema(meta_schema)
if has_anonymous_link(node, auth):
for indx, schema_page in enumerate(my_meta['schema']['pages']):
for idx, schema_question in enumerate(schema_page['questions']):
if schema_question['title'] in settings.ANONYMIZED_TITLES:
del my_meta['schema']['pages'][indx]['questions'][idx]
ret['node']['registered_schema'] = serialize_meta_schema(meta_schema)
return ret
else:
status.push_status_message(
'You have been redirected to the project\'s registrations page. From here you can initiate a new Draft Registration to complete the registration process',
trust=False
)
return redirect(node.web_url_for('node_registrations', view=kwargs.get('template')))
def node_register_template_page(auth, node, metaschema_id, **kwargs):
if node.is_registration and bool(node.registered_schema):
try:
meta_schema = RegistrationSchema.objects.get(_id=metaschema_id)
except RegistrationSchema.DoesNotExist:
# backwards compatability for old urls, lookup by name
meta_schema = RegistrationSchema.objects.filter(name=_id_to_name(metaschema_id)).order_by('-schema_version').first()
if not meta_schema:
raise HTTPError(http.NOT_FOUND, data={
'message_short': 'Invalid schema name',
'message_long': 'No registration schema with that name could be found.'
})
if not node.registered_schema.filter(id=meta_schema.id).exists():
raise HTTPError(http.BAD_REQUEST, data={
'message_short': 'Invalid schema',
'message_long': 'This registration has no registration supplment with that name.'
})
ret = _view_project(node, auth, primary=True)
my_meta = serialize_meta_schema(meta_schema)
if has_anonymous_link(node, auth):
for indx, schema_page in enumerate(my_meta['schema']['pages']):
for idx, schema_question in enumerate(schema_page['questions']):
if schema_question['title'] in settings.ANONYMIZED_TITLES:
del my_meta['schema']['pages'][indx]['questions'][idx]
ret['node']['registered_schema'] = serialize_meta_schema(meta_schema)
return ret
else:
status.push_status_message(
'You have been redirected to the project\'s registrations page. From here you can initiate a new Draft Registration to complete the registration process',
trust=False,
id='redirected_to_registrations',
)
return redirect(node.web_url_for('node_registrations', view=kwargs.get('template'), _guid=True))
def serialize_draft_registration(draft, auth=None):
import sys
sys.path.insert(0, submodule_path('utils.py'))
from website.profile.utils import serialize_user # noqa
node = draft.branched_from
return {
'pk': draft._id,
'branched_from': serialize_node(draft.branched_from, auth),
'initiator': serialize_user(draft.initiator, full=True),
'registration_metadata': draft.registration_metadata,
'registration_schema':
serialize_meta_schema(draft.registration_schema),
'initiated': str(draft.datetime_initiated),
'updated': str(draft.datetime_updated),
'flags': draft.flags,
'requires_approval': draft.requires_approval,
#'is_pending_approval': draft.is_pending_review,
#'is_approved': draft.is_approved,
'approval': serialize_draft_registration_approval(draft.approval)
# 'urls': {
# 'edit': node.web_url_for('edit_draft_registration_page', draft_id=draft._id),
# 'before_register': node.api_url_for('project_before_register'),
# 'register': node.api_url_for('register_draft_registration', draft_id=draft._id),
# 'register_page': node.web_url_for('draft_before_register_page', draft_id=draft._id),
# 'registrations': node.web_url_for('node_registrations')
# }
}
def serialize_draft_registration(draft, auth=None):
import sys
sys.path.insert(0, submodule_path('utils.py'))
from website.profile.utils import serialize_user # noqa
#import ipdb; ipdb.set_trace()
node = draft.branched_from
return {
'pk': draft._id,
'branched_from': serialize_node(draft.branched_from, auth),
'initiator': serialize_user(draft.initiator, full=True),
'registration_metadata': draft.registration_metadata,
'registration_schema': serialize_meta_schema(draft.registration_schema),
'initiated': str(draft.datetime_initiated),
'updated': str(draft.datetime_updated),
'config': draft.config or {},
'flags': draft.flags,
# 'urls': {
# 'edit': node.web_url_for('edit_draft_registration_page', draft_id=draft._id),
# 'before_register': node.api_url_for('project_before_register'),
# 'register': node.api_url_for('register_draft_registration', draft_id=draft._id),
# 'register_page': node.web_url_for('draft_before_register_page', draft_id=draft._id),
# 'registrations': node.web_url_for('node_registrations')
# }
}
def node_register_template_page(auth, node, metaschema_id, **kwargs):
if node.is_registration and bool(node.registered_schema):
try:
meta_schema = MetaSchema.find_one(
Q('_id', 'eq', metaschema_id)
)
except NoResultsFound:
# backwards compatability for old urls, lookup by name
try:
meta_schema = MetaSchema.find(
Q('name', 'eq', _id_to_name(metaschema_id))
).sort('-schema_version')[0]
except IndexError:
raise HTTPError(http.NOT_FOUND, data={
'message_short': 'Invalid schema name',
'message_long': 'No registration schema with that name could be found.'
})
if meta_schema not in node.registered_schema:
raise HTTPError(http.BAD_REQUEST, data={
'message_short': 'Invalid schema',
'message_long': 'This registration has no registration supplment with that name.'
})
ret = _view_project(node, auth, primary=True)
ret['node']['registered_schema'] = serialize_meta_schema(meta_schema)
return ret
else:
status.push_status_message(
'You have been redirected to the project\'s registrations page. From here you can initiate a new Draft Registration to complete the registration process',
trust=False
)
return redirect(node.web_url_for('node_registrations', view=kwargs.get('template')))
def get_metaschemas(*args, **kwargs):
"""
List metaschemas with which a draft registration may be created. Only fetch the newest version for each schema.
:return: serialized metaschemas
:rtype: dict
"""
count = request.args.get('count', 100)
include = request.args.get('include', 'latest')
meta_schemas = []
if include == 'latest':
schema_names = list(MetaSchema.objects.all().values_list('name', flat=True).distinct())
for name in schema_names:
meta_schema_set = MetaSchema.find(
Q('name', 'eq', name) &
Q('schema_version', 'eq', 2)
)
meta_schemas = meta_schemas + [s for s in meta_schema_set]
else:
meta_schemas = MetaSchema.find()
meta_schemas = [
schema
for schema in meta_schemas
if schema.active
]
meta_schemas.sort(key=lambda a: METASCHEMA_ORDERING.index(a.name))
return {
'meta_schemas': [
serialize_meta_schema(ms) for ms in meta_schemas[:count]
]
}, http.OK
def get_metaschemas(*args, **kwargs):
"""
List metaschemas with which a draft registration may be created. Only fetch the newest version for each schema.
:return: serialized metaschemas
:rtype: dict
"""
count = request.args.get('count', 100)
include = request.args.get('include', 'latest')
meta_schema_collection = database['metaschema']
meta_schemas = []
if include == 'latest':
schema_names = meta_schema_collection.distinct('name')
for name in schema_names:
meta_schema_set = MetaSchema.find(
Q('name', 'eq', name) & Q('schema_version', 'eq', 2))
meta_schemas = meta_schemas + [s for s in meta_schema_set]
else:
meta_schemas = MetaSchema.find()
meta_schemas = [
schema for schema in meta_schemas if schema.name in ACTIVE_META_SCHEMAS
]
meta_schemas.sort(key=lambda a: ACTIVE_META_SCHEMAS.index(a.name))
return {
'meta_schemas':
[serialize_meta_schema(ms) for ms in meta_schemas[:count]]
}, http.OK
def serialize_draft_registration(draft, json_safe=True):
if draft.branched_from is not None:
url = furl(OSF_DOMAIN)
url.path.add(draft.branched_from.url)
node_url = url.url
else:
node_url = None
registration_choice = draft.approval.meta.get('registration_choice', None)
if registration_choice == EMBARGO:
time = parser.parse(draft.approval.meta['embargo_end_date'])
embargo = iso8601format(time) if json_safe else time
else:
embargo = IMMEDIATE
return {
'pk': draft._id,
'initiator': serialize_user(draft.initiator),
'registration_metadata': draft.registration_metadata,
'registration_schema': serialize_meta_schema(draft.registration_schema),
'initiated': iso8601format(draft.datetime_initiated) if json_safe else draft.datetime_initiated,
'updated': iso8601format(draft.datetime_updated) if json_safe else draft.datetime_updated,
'submitted': iso8601format(draft.approval.initiation_date) if json_safe else draft.approval.initiation_date,
'requires_approval': draft.requires_approval,
'is_pending_approval': draft.is_pending_review,
'is_approved': draft.is_approved,
'is_rejected': draft.is_rejected,
'notes': draft.notes,
'proof_of_publication': draft.flags.get('proof_of_publication'),
'payment_sent': draft.flags.get('payment_sent'),
'assignee': draft.flags.get('assignee'),
'title': draft.registration_metadata['q1']['value'],
'embargo': embargo,
'registered_node': node_url,
}
def serialize_draft_registration(draft, json_safe=True):
node_url = get_url(draft)
embargo = get_embargo(draft, json_safe)
submitted = None
if draft.approval is not None:
if json_safe:
submitted = iso8601format(draft.approval.initiation_date)
else:
submitted = draft.approval.initiation_date
return {
'pk': draft._id,
'initiator': serialize_user(draft.initiator),
'registration_metadata': draft.registration_metadata,
'registration_schema': serialize_meta_schema(draft.registration_schema),
'initiated': iso8601format(draft.datetime_initiated) if json_safe else draft.datetime_initiated,
'updated': iso8601format(draft.datetime_updated) if json_safe else draft.datetime_updated,
'submitted': submitted,
'requires_approval': draft.requires_approval,
'is_pending_approval': draft.is_pending_review,
'is_approved': draft.is_approved,
'is_rejected': draft.is_rejected,
'notes': draft.notes,
'proof_of_publication': draft.flags.get('proof_of_publication'),
'payment_sent': draft.flags.get('payment_sent'),
'assignee': draft.flags.get('assignee'),
'title': draft.registration_metadata['q1']['value'],
'embargo': embargo,
'registered_node': node_url,
'status': get_approval_status(draft),
'logs': map(serialize_draft_logs, draft.status_logs),
}
def serialize_draft_registration(draft, json_safe=True):
node_url = get_url(draft)
embargo = get_embargo(draft, json_safe)
submitted = None
if draft.approval is not None:
if json_safe:
submitted = iso8601format(draft.approval.initiation_date)
else:
submitted = draft.approval.initiation_date
return {
'pk': draft._id,
'initiator': serialize_user(draft.initiator),
'registration_metadata': draft.registration_metadata,
'registration_schema': serialize_meta_schema(draft.registration_schema),
'initiated': iso8601format(draft.datetime_initiated) if json_safe else draft.datetime_initiated,
'updated': iso8601format(draft.datetime_updated) if json_safe else draft.datetime_updated,
'submitted': submitted,
'requires_approval': draft.requires_approval,
'is_pending_approval': draft.is_pending_review,
'is_approved': draft.is_approved,
'is_rejected': draft.is_rejected,
'notes': draft.notes,
'proof_of_publication': draft.flags.get('proof_of_publication'),
'payment_sent': draft.flags.get('payment_sent'),
'assignee': draft.flags.get('assignee'),
'title': draft.registration_metadata['q1']['value'],
'embargo': embargo,
'registered_node': node_url,
'status': get_approval_status(draft),
'logs': list(map(serialize_draft_logs, draft.status_logs)),
}
def get_metaschemas(*args, **kwargs):
"""
List metaschemas with which a draft registration may be created. Only fetch the newest version for each schema.
:return: serialized metaschemas
:rtype: dict
"""
count = request.args.get('count', 100)
include = request.args.get('include', 'latest')
meta_schemas = []
if include == 'latest':
schema_names = list(MetaSchema.objects.all().values_list('name', flat=True).distinct())
for name in schema_names:
meta_schema_set = MetaSchema.find(
Q('name', 'eq', name) &
Q('schema_version', 'eq', 2)
)
meta_schemas = meta_schemas + [s for s in meta_schema_set]
else:
meta_schemas = MetaSchema.find()
meta_schemas = [
schema
for schema in meta_schemas
if schema.active
]
meta_schemas.sort(key=lambda a: METASCHEMA_ORDERING.index(a.name))
return {
'meta_schemas': [
serialize_meta_schema(ms) for ms in meta_schemas[:count]
]
}, http.OK
def serialize_draft_registration(draft, auth=None):
import sys
sys.path.insert(0, submodule_path('utils.py'))
from website.profile.utils import serialize_user # noqa
node = draft.branched_from
return {
'pk': draft._id,
'branched_from': serialize_node(draft.branched_from, auth),
'initiator': serialize_user(draft.initiator, full=True),
'registration_metadata': draft.registration_metadata,
'registration_schema': serialize_meta_schema(draft.registration_schema),
'initiated': str(draft.datetime_initiated),
'updated': str(draft.datetime_updated),
'flags': draft.flags,
'requires_approval': draft.requires_approval,
#'is_pending_approval': draft.is_pending_review,
#'is_approved': draft.is_approved,
'approval': serialize_draft_registration_approval(draft.approval)
# 'urls': {
# 'edit': node.web_url_for('edit_draft_registration_page', draft_id=draft._id),
# 'before_register': node.api_url_for('project_before_register'),
# 'register': node.api_url_for('register_draft_registration', draft_id=draft._id),
# 'register_page': node.web_url_for('draft_before_register_page', draft_id=draft._id),
# 'registrations': node.web_url_for('node_registrations')
# }
}
def get_metaschemas(*args, **kwargs):
"""
List metaschemas with which a draft registration may be created. Only fetch the newest version for each schema.
:return: serialized metaschemas
:rtype: dict
"""
count = request.args.get('count', 100)
include = request.args.get('include', 'latest')
meta_schema_collection = database['metaschema']
meta_schemas = []
if include == 'latest':
schema_names = meta_schema_collection.distinct('name')
for name in schema_names:
meta_schema_set = MetaSchema.find(
Q('name', 'eq', name) &
Q('schema_version', 'eq', 2)
)
meta_schemas = meta_schemas + [s for s in meta_schema_set]
else:
meta_schemas = MetaSchema.find()
meta_schemas = [
schema
for schema in meta_schemas
if schema.name in ACTIVE_META_SCHEMAS
]
meta_schemas.sort(key=lambda a: ACTIVE_META_SCHEMAS.index(a.name))
return {
'meta_schemas': [
serialize_meta_schema(ms) for ms in meta_schemas[:count]
]
}, http.OK
def serialize_draft_registration(draft, json_safe=True):
if draft.branched_from is not None:
url = furl(OSF_DOMAIN)
url.path.add(draft.branched_from.url)
node_url = url.url
else:
node_url = None
registration_choice = draft.approval.meta.get('registration_choice', None)
if registration_choice == EMBARGO:
time = parser.parse(draft.approval.meta['embargo_end_date'])
embargo = iso8601format(time) if json_safe else time
else:
embargo = IMMEDIATE
return {
'pk':
draft._id,
'initiator':
serialize_user(draft.initiator),
'registration_metadata':
draft.registration_metadata,
'registration_schema':
serialize_meta_schema(draft.registration_schema),
'initiated':
iso8601format(draft.datetime_initiated)
if json_safe else draft.datetime_initiated,
'updated':
iso8601format(draft.datetime_updated)
if json_safe else draft.datetime_updated,
'submitted':
iso8601format(draft.approval.initiation_date)
if json_safe else draft.approval.initiation_date,
'requires_approval':
draft.requires_approval,
'is_pending_approval':
draft.is_pending_review,
'is_approved':
draft.is_approved,
'is_rejected':
draft.is_rejected,
'notes':
draft.notes,
'proof_of_publication':
draft.flags.get('proof_of_publication'),
'payment_sent':
draft.flags.get('payment_sent'),
'assignee':
draft.flags.get('assignee'),
'title':
draft.registration_metadata['q1']['value'],
'embargo':
embargo,
'registered_node':
node_url,
}
def node_register_template_page(auth, node, metaschema_id, **kwargs):
if flag_is_active(request, features.EMBER_REGISTRIES_DETAIL_PAGE):
# Registration meta page obviated during redesign
return redirect(node.url)
if node.is_registration and bool(node.registered_schema):
try:
meta_schema = RegistrationSchema.objects.get(_id=metaschema_id)
except RegistrationSchema.DoesNotExist:
# backwards compatability for old urls, lookup by name
meta_schema = RegistrationSchema.objects.filter(name=_id_to_name(
metaschema_id)).order_by('-schema_version').first()
if not meta_schema:
raise HTTPError(
http_status.HTTP_404_NOT_FOUND,
data={
'message_short':
'Invalid schema name',
'message_long':
'No registration schema with that name could be found.'
})
ret = _view_project(node, auth, primary=True)
my_meta = serialize_meta_schema(meta_schema)
if has_anonymous_link(node, auth):
for indx, schema_page in enumerate(my_meta['schema']['pages']):
for idx, schema_question in enumerate(
schema_page['questions']):
if schema_question['title'] in settings.ANONYMIZED_TITLES:
del my_meta['schema']['pages'][indx]['questions'][idx]
ret['node']['registered_schema'] = serialize_meta_schema(meta_schema)
return ret
else:
status.push_status_message(
'You have been redirected to the project\'s registrations page. From here you can initiate a new Draft Registration to complete the registration process',
trust=False,
id='redirected_to_registrations',
)
return redirect(
node.web_url_for('node_registrations',
view=kwargs.get('template'),
_guid=True))
def get_metaschemas(*args, **kwargs):
"""
List metaschemas with which a draft registration may be created. Only fetch the newest version for each schema.
:return: serialized metaschemas
:rtype: dict
"""
count = request.args.get('count', 100)
include = request.args.get('include', 'latest')
meta_schemas = RegistrationSchema.objects.filter(active=True)
if include == 'latest':
meta_schemas = RegistrationSchema.objects.get_latest_versions()
meta_schemas = sorted(meta_schemas, key=order_schemas)
return {
'meta_schemas':
[serialize_meta_schema(ms) for ms in meta_schemas[:count]]
}, http_status.HTTP_200_OK
def serialize_draft_registration(draft, json_safe=True):
return {
'pk': draft._id,
'initiator': serialize_user(draft.initiator),
'registration_metadata': draft.registration_metadata,
'registration_schema': serialize_meta_schema(draft.registration_schema),
'initiated': iso8601format(draft.datetime_initiated) if json_safe else draft.datetime_initiated,
'updated': iso8601format(draft.datetime_updated) if json_safe else draft.datetime_updated,
'submitted': iso8601format(draft.approval.initiation_date) if json_safe else draft.approval.initiation_date,
'requires_approval': draft.requires_approval,
'is_pending_approval': draft.is_pending_review,
'is_approved': draft.is_approved,
'is_rejected': draft.is_rejected,
'notes': draft.notes,
'proof_of_publication': draft.flags.get('proof_of_publication'),
'payment_sent': draft.flags.get('payment_sent'),
'assignee': draft.flags.get('assignee'),
'title': draft.registration_metadata['q1']['value'],
}
def get_metaschemas(*args, **kwargs):
"""
List metaschemas with which a draft registration may be created. Only fetch the newest version for each schema.
:return: serialized metaschemas
:rtype: dict
"""
count = request.args.get('count', 100)
include = request.args.get('include', 'latest')
meta_schemas = MetaSchema.objects.filter(active=True)
if include == 'latest':
meta_schemas.filter(schema_version=LATEST_SCHEMA_VERSION)
meta_schemas = sorted(meta_schemas, key=lambda x: METASCHEMA_ORDERING.index(x.name))
return {
'meta_schemas': [
serialize_meta_schema(ms) for ms in meta_schemas[:count]
]
}, http.OK
def get_metaschemas(*args, **kwargs):
"""
List metaschemas with which a draft registration may be created. Only fetch the newest version for each schema.
:return: serialized metaschemas
:rtype: dict
"""
count = request.args.get('count', 100)
include = request.args.get('include', 'latest')
meta_schemas = RegistrationSchema.objects.filter(active=True)
if include == 'latest':
meta_schemas.filter(schema_version=LATEST_SCHEMA_VERSION)
meta_schemas = sorted(meta_schemas,
key=lambda x: METASCHEMA_ORDERING.index(x.name))
return {
'meta_schemas':
[serialize_meta_schema(ms) for ms in meta_schemas[:count]]
}, http.OK
def node_register_template_page(auth, node, metaschema_id, **kwargs):
if node.is_registration and bool(node.registered_schema):
try:
meta_schema = MetaSchema.find_one(Q('_id', 'eq', metaschema_id))
except NoResultsFound:
# backwards compatability for old urls, lookup by name
try:
meta_schema = MetaSchema.find(
Q('name', 'eq',
_id_to_name(metaschema_id))).sort('-schema_version')[0]
except IndexError:
raise HTTPError(
http.NOT_FOUND,
data={
'message_short':
'Invalid schema name',
'message_long':
'No registration schema with that name could be found.'
})
if meta_schema not in node.registered_schema:
raise HTTPError(
http.BAD_REQUEST,
data={
'message_short':
'Invalid schema',
'message_long':
'This registration has no registration supplment with that name.'
})
ret = _view_project(node, auth, primary=True)
ret['node']['registered_schema'] = serialize_meta_schema(meta_schema)
return ret
else:
status.push_status_message(
'You have been redirected to the project\'s registrations page. From here you can initiate a new Draft Registration to complete the registration process',
trust=False)
return redirect(
node.web_url_for('node_registrations',
view=kwargs.get('template')))
def serialize_node(node, auth, primary=False):
"""Build a JSON object containing everything needed to render
project.view.mako.
"""
user = auth.user
parent = node.parent_node
data = {
'node': {
'id':
node._primary_key,
'title':
node.title,
'category':
node.category_display,
'category_short':
node.category,
'node_type':
node.project_or_component,
'description':
node.description or '',
'url':
node.url,
'api_url':
node.api_url,
'absolute_url':
node.absolute_url,
'display_absolute_url':
node.display_absolute_url,
'is_public':
node.is_public,
'is_archiving':
node.archiving,
'date_created':
iso8601format(node.date_created),
'date_modified':
iso8601format(node.logs[-1].date) if node.logs else '',
'tags': [tag._primary_key for tag in node.tags],
'children':
bool(node.nodes),
'is_registration':
node.is_registration,
'is_retracted':
node.is_retracted,
'pending_retraction':
node.pending_retraction,
'retracted_justification':
getattr(node.retraction, 'justification', None),
'embargo_end_date':
node.embargo_end_date.strftime("%A, %b. %d, %Y")
if node.embargo_end_date else False,
'pending_embargo':
node.pending_embargo,
'registered_from_url':
node.registered_from.url if node.is_registration else '',
'registered_date':
iso8601format(node.registered_date)
if node.is_registration else '',
'root_id':
node.root._id,
'registered_meta':
node.registered_meta,
'registered_schema':
serialize_meta_schema(node.registered_schema),
'registration_count':
len(node.node__registrations),
'is_fork':
node.is_fork,
'forked_from_id':
node.forked_from._primary_key if node.is_fork else '',
'forked_from_display_absolute_url':
node.forked_from.display_absolute_url if node.is_fork else '',
'forked_date':
iso8601format(node.forked_date) if node.is_fork else '',
'fork_count':
len(node.forks),
'templated_count':
len(node.templated_list),
'watched_count':
len(node.watchconfig__watched),
'private_links': [x.to_json() for x in node.private_links_active],
'points':
len(node.get_points(deleted=False, folders=False)),
'piwik_site_id':
node.piwik_site_id,
'comment_level':
node.comment_level,
'has_comments':
bool(getattr(node, 'commented', [])),
'has_children':
bool(getattr(node, 'commented', False)),
'identifiers': {
'doi': node.get_identifier_value('doi'),
'ark': node.get_identifier_value('ark'),
},
},
'parent_node': {
'exists':
parent is not None,
'id':
parent._primary_key if parent else '',
'title':
parent.title if parent else '',
'category':
parent.category_display if parent else '',
'url':
parent.url if parent else '',
'api_url':
parent.api_url if parent else '',
'absolute_url':
parent.absolute_url if parent else '',
'registrations_url':
parent.web_url_for('node_registrations') if parent else '',
'is_public':
parent.is_public if parent else '',
'is_contributor':
parent.is_contributor(user) if parent else '',
'can_view':
parent.can_view(auth) if parent else False
},
'user': {
'is_contributor': node.is_contributor(user),
'is_admin_parent':
parent.is_admin_parent(user) if parent else False,
'can_edit': (node.can_edit(auth) and not node.is_registration),
'has_read_permissions': node.has_permission(user, 'read'),
'permissions': node.get_permissions(user) if user else [],
'is_watching': user.is_watching(node) if user else False,
'piwik_token': user.piwik_token if user else '',
'id': user._id if user else None,
'username': user.username if user else None,
'fullname': user.fullname if user else '',
'can_comment': node.can_comment(auth),
},
# TODO: Namespace with nested dicts
'addons_enabled': node.get_addon_names(),
'node_categories': Node.CATEGORY_MAP,
}
return data
def get_metaschema(schema_name, schema_version=1):
meta_schema = get_schema_or_fail(
Q('name', 'eq', schema_name) &
Q('schema_version', 'eq', schema_version)
)
return serialize_meta_schema(meta_schema), http.OK
def serialize_node(node, auth, primary=False):
"""Build a JSON object containing everything needed to render
project.view.mako.
"""
user = auth.user
parent = node.parent_node
data = {
'node': {
'id': node._primary_key,
'title': node.title,
'category': node.category_display,
'category_short': node.category,
'node_type': node.project_or_component,
'description': node.description or '',
'url': node.url,
'api_url': node.api_url,
'absolute_url': node.absolute_url,
'display_absolute_url': node.display_absolute_url,
'is_public': node.is_public,
'is_archiving': node.archiving,
'date_created': iso8601format(node.date_created),
'date_modified': iso8601format(node.logs[-1].date) if node.logs else '',
'tags': [tag._primary_key for tag in node.tags],
'children': bool(node.nodes),
'is_registration': node.is_registration,
'is_retracted': node.is_retracted,
'pending_retraction': node.pending_retraction,
'retracted_justification': getattr(node.retraction, 'justification', None),
'embargo_end_date': node.embargo_end_date.strftime("%A, %b. %d, %Y") if node.embargo_end_date else False,
'pending_embargo': node.pending_embargo,
'registered_from_url': node.registered_from.url if node.is_registration else '',
'registered_date': iso8601format(node.registered_date) if node.is_registration else '',
'root_id': node.root._id,
'registered_meta': node.registered_meta,
'registered_schema': serialize_meta_schema(node.registered_schema),
'registration_count': len(node.node__registrations),
'is_fork': node.is_fork,
'forked_from_id': node.forked_from._primary_key if node.is_fork else '',
'forked_from_display_absolute_url': node.forked_from.display_absolute_url if node.is_fork else '',
'forked_date': iso8601format(node.forked_date) if node.is_fork else '',
'fork_count': len(node.forks),
'templated_count': len(node.templated_list),
'watched_count': len(node.watchconfig__watched),
'private_links': [x.to_json() for x in node.private_links_active],
'points': len(node.get_points(deleted=False, folders=False)),
'piwik_site_id': node.piwik_site_id,
'comment_level': node.comment_level,
'has_comments': bool(getattr(node, 'commented', [])),
'has_children': bool(getattr(node, 'commented', False)),
'identifiers': {
'doi': node.get_identifier_value('doi'),
'ark': node.get_identifier_value('ark'),
},
},
'parent_node': {
'exists': parent is not None,
'id': parent._primary_key if parent else '',
'title': parent.title if parent else '',
'category': parent.category_display if parent else '',
'url': parent.url if parent else '',
'api_url': parent.api_url if parent else '',
'absolute_url': parent.absolute_url if parent else '',
'registrations_url': parent.web_url_for('node_registrations') if parent else '',
'is_public': parent.is_public if parent else '',
'is_contributor': parent.is_contributor(user) if parent else '',
'can_view': parent.can_view(auth) if parent else False
},
'user': {
'is_contributor': node.is_contributor(user),
'is_admin_parent': parent.is_admin_parent(user) if parent else False,
'can_edit': (node.can_edit(auth)
and not node.is_registration),
'has_read_permissions': node.has_permission(user, 'read'),
'permissions': node.get_permissions(user) if user else [],
'is_watching': user.is_watching(node) if user else False,
'piwik_token': user.piwik_token if user else '',
'id': user._id if user else None,
'username': user.username if user else None,
'fullname': user.fullname if user else '',
'can_comment': node.can_comment(auth),
},
# TODO: Namespace with nested dicts
'addons_enabled': node.get_addon_names(),
'node_categories': Node.CATEGORY_MAP,
}
return data
def get_metaschema(schema_name, schema_version=1):
meta_schema = get_schema_or_fail(
Q('name', 'eq', schema_name)
& Q('schema_version', 'eq', schema_version))
return serialize_meta_schema(meta_schema), http.OK
