def wrapped(*args, **kwargs):
node = get_or_http_error(Node, kwargs.get("nid", kwargs.get("pid")), allow_deleted=True)
if node.sanction and node.sanction.is_rejected:
raise HTTPError(http.GONE, data=dict(message_long="This registration has been rejected"))
return func(*args, **kwargs)
def test_get_or_http_error_by_query_found(self):
n = factories.NodeFactory()
found = get_or_http_error(
Node,
(Q('title', 'eq', n.title) & Q('_id', 'eq', n._id))
)
assert_equal(found, n)
def update_draft(request, draft_pk):
get_schema_or_fail = lambda query: get_or_http_error(MetaSchema, query)
data = json.load(request)
draft = get_draft_obj(draft_pk)
schema_data = data['schema_data']
schema_name = data['schema_name']
schema_version = data['schema_version']
if schema_name:
meta_schema = get_schema_or_fail(
Q('name', 'eq', schema_name) &
Q('schema_version', 'eq', schema_version)
)
existing_schema = draft[0].registration_schema
if (existing_schema.name, existing_schema.schema_version) != (meta_schema.name, meta_schema.schema_version):
draft[0].registration_schema = meta_schema
try:
draft[0].update_metadata(schema_data)
except (NodeStateError):
raise HTTPError(http.BAD_REQUEST)
response = serialize_draft_registration(draft[0], draft[1])
return HttpResponse(json.dumps(response), content_type='application/json')
def wrapped(*args, **kwargs):
node = get_or_http_error(Node,
kwargs.get('nid', kwargs.get('pid')),
allow_deleted=True)
if node.sanction and node.sanction.is_rejected:
raise HTTPError(
http.GONE,
data=dict(message_long="This registration has been rejected"))
return func(*args, **kwargs)
def add_folder(auth, **kwargs):
data = request.get_json()
node_id = data.get("node_id")
node = get_or_http_error(Node, node_id)
user = auth.user
title = strip_html(data.get("title"))
if not node.is_folder:
raise HTTPError(http.BAD_REQUEST)
folder = new_folder(title, user)
folders = [folder]
try:
_add_pointers(node, folders, auth)
except ValueError:
raise HTTPError(http.BAD_REQUEST)
return {}, 201, None
def add_folder(auth, **kwargs):
data = request.get_json()
node_id = data.get('node_id')
node = get_or_http_error(Node, node_id)
user = auth.user
title = strip_html(data.get('title'))
if not node.is_folder:
raise HTTPError(http.BAD_REQUEST)
folder = new_folder(title, user)
folders = [folder]
try:
_add_pointers(node, folders, auth)
except ValueError:
raise HTTPError(http.BAD_REQUEST)
return {}, 201, None
from website.util.permissions import ADMIN
from website.project.decorators import (
must_be_valid_project,
must_have_permission,
http_error_if_disk_saving_mode
)
from website import language, settings
from website.project import utils as project_utils
from website.project.model import MetaSchema, DraftRegistration
from website.project.metadata.schemas import ACTIVE_META_SCHEMAS
from website.project.metadata.utils import serialize_meta_schema, serialize_draft_registration
from website.project.utils import serialize_node
from website.util import rapply
from website.util.sanitize import strip_html
get_schema_or_fail = lambda query: get_or_http_error(MetaSchema, query)
autoload_draft = functools.partial(autoload, DraftRegistration, 'draft_id', 'draft')
def must_be_branched_from_node(func):
@autoload_draft
@must_be_valid_project
@functools.wraps(func)
def wrapper(*args, **kwargs):
node = kwargs['node']
draft = kwargs['draft']
if not draft.branched_from._id == node._id:
raise HTTPError(
http.BAD_REQUEST,
data={
'message_short': 'Not a draft of this node',
'message_long': 'This draft registration is not created from the given node.'
def test_get_or_http_error_by_query_not_unique(self):
title = 'TITLE'
factories.NodeFactory(title=title)
factories.NodeFactory(title=title)
with assert_raises(HTTPError):
get_or_http_error(Node, Q('title', 'eq', title))
def test_get_or_http_error_by_pk_found(self):
n = factories.NodeFactory()
found = get_or_http_error(Node, n._id)
assert found == n
def test_get_or_http_error_by_query_not_found(self):
with assert_raises(HTTPError):
get_or_http_error(Node, Q('_id', 'eq', 'blah'))
def test_get_or_http_error_by_pk_found(self):
n = factories.NodeFactory()
found = get_or_http_error(Node, n._id)
assert_equal(found, n)
def test_get_or_http_error_by_pk_not_found(self):
with assert_raises(HTTPError):
get_or_http_error(Node, 'blah')
import functools
import httplib as http
from furl import furl
from flask import request
from framework import status
from framework.auth import Auth, cas
from framework.flask import redirect # VOL-aware redirect
from framework.exceptions import HTTPError
from framework.auth.decorators import collect_auth
from framework.mongo.utils import get_or_http_error
from website.models import Node
_load_node_or_fail = lambda pk: get_or_http_error(Node, pk)
def _kwargs_to_nodes(kwargs):
"""Retrieve project and component objects from keyword arguments.
:param dict kwargs: Dictionary of keyword arguments
:return: Tuple of parent and node
"""
node = kwargs.get("node") or kwargs.get("project")
parent = kwargs.get("parent")
if node:
return parent, node
pid = kwargs.get("pid")
def test_get_or_http_error_by_pk_not_found(self):
with pytest.raises(HTTPError):
get_or_http_error(Node, 'blah')
def test_get_or_http_error_by_query_found(self):
n = factories.NodeFactory()
found = get_or_http_error(
Node, (Q('title', 'eq', n.title) & Q('_id', 'eq', n._id)))
assert found == n
from flask import request
from modularodm import Q
from modularodm.exceptions import ModularOdmException
from framework import status
from framework.auth import Auth, cas
from framework.flask import redirect # VOL-aware redirect
from framework.exceptions import HTTPError
from framework.auth.decorators import collect_auth
from framework.mongo.utils import get_or_http_error
from website.models import Node
from website import settings
_load_node_or_fail = lambda pk: get_or_http_error(Node, pk)
def _kwargs_to_nodes(kwargs):
"""Retrieve project and component objects from keyword arguments.
:param dict kwargs: Dictionary of keyword arguments
:return: Tuple of parent and node
"""
node = kwargs.get('node') or kwargs.get('project')
parent = kwargs.get('parent')
if node:
return parent, node
pid = kwargs.get('pid')
from website.exceptions import NodeStateError
from website.util.permissions import ADMIN
from website.project.decorators import (must_be_valid_project,
must_have_permission,
http_error_if_disk_saving_mode)
from website import language, settings
from website.project import utils as project_utils
from website.project.model import MetaSchema, DraftRegistration
from website.project.metadata.schemas import ACTIVE_META_SCHEMAS
from website.project.metadata.utils import serialize_meta_schema, serialize_draft_registration
from website.project.utils import serialize_node
from website.util import rapply
from website.util.sanitize import strip_html
get_schema_or_fail = lambda query: get_or_http_error(MetaSchema, query)
autoload_draft = functools.partial(autoload, DraftRegistration, 'draft_id',
'draft')
def must_be_branched_from_node(func):
@autoload_draft
@must_be_valid_project
@functools.wraps(func)
def wrapper(*args, **kwargs):
node = kwargs['node']
draft = kwargs['draft']
if not draft.branched_from._id == node._id:
raise HTTPError(
http.BAD_REQUEST,
data={
def test_get_or_http_error_by_query_not_unique(self):
title = 'TITLE'
factories.NodeFactory(title=title)
factories.NodeFactory(title=title)
with pytest.raises(HTTPError):
get_or_http_error(Node, Q('title', 'eq', title))
def test_get_or_http_error_by_query_not_found(self):
with pytest.raises(HTTPError):
get_or_http_error(Node, Q('_id', 'eq', 'blah'))
