def test_create(self):
from invenio.ext.login.legacy_user import UserInfo
from invenio.modules.deposit.models import Deposition
user = UserInfo(uid=1)
d = Deposition.create(user)
assert d.type == self.DefaultType
assert Deposition.get(d.id).type == self.DefaultType
d = Deposition.create(user, type=self.AnotherType)
assert d.type == self.AnotherType
assert Deposition.get(d.id).type == self.AnotherType
def test_create(self):
from invenio.ext.login.legacy_user import UserInfo
from invenio.modules.deposit.models import Deposition
user = UserInfo(uid=1)
d = Deposition.create(user)
assert d.type == self.DefaultType
assert Deposition.get(d.id).type == self.DefaultType
d = Deposition.create(user, type=self.AnotherType)
assert d.type == self.AnotherType
assert Deposition.get(d.id).type == self.AnotherType
def run_deposition_tasks(self, deposition_id, with_webcoll=True):
"""
Run all task ids specified in the latest SIP and optionally run
webcoll.
"""
# Run submitted tasks
from invenio.modules.deposit.models import Deposition
dep = Deposition.get(deposition_id)
sip = dep.get_latest_sip(sealed=True)
for task_id in sip.task_ids:
self.run_task_id(task_id)
if with_webcoll:
# Run webcoll (to ensure record is assigned permissions)
from invenio.legacy.bibsched.bibtask import \
task_low_level_submission
task_id = task_low_level_submission('webcoll', 'webdeposit', '-q')
self.run_task_id(task_id)
# Check if record is accessible
response = self.client.get(
url_for('record.metadata', recid=sip.metadata['recid']),
base_url=self.app.config['CFG_SITE_SECURE_URL'],
)
self.assertStatus(response, 200)
def test_create(self):
"""Test."""
from invenio.ext.login.legacy_user import UserInfo
from invenio.modules.deposit.models import Deposition
user = UserInfo(uid=1)
d = Deposition.create(user)
assert d.type == self.DefaultType
assert Deposition.get(d.id).type == self.DefaultType
d2 = Deposition.create(user, type=self.AnotherType)
assert d2.type == self.AnotherType
assert Deposition.get(d2.id).type == self.AnotherType
# remove the records
Deposition.delete(d)
Deposition.delete(d2)
def get(self, resource_id, file_id):
"""Get a deposition file."""
d = Deposition.get(resource_id, user=current_user)
df = d.get_file(file_id)
if df is None:
abort(404, message="File does not exist", status=404)
return d.type.marshal_file(df)
def run_deposition_tasks(self, deposition_id, with_webcoll=True):
"""
Run all task ids specified in the latest SIP and optionally run
webcoll.
"""
# Run submitted tasks
from invenio.modules.deposit.models import Deposition
dep = Deposition.get(deposition_id)
sip = dep.get_latest_sip(sealed=True)
for task_id in sip.task_ids:
self.run_task_id(task_id)
if with_webcoll:
# Run webcoll (to ensure record is assigned permissions)
from invenio.legacy.bibsched.bibtask import \
task_low_level_submission
task_id = task_low_level_submission('webcoll', 'webdeposit', '-q')
self.run_task_id(task_id)
# Check if record is accessible
response = self.client.get(
url_for('record.metadata', recid=sip.metadata['recid']),
base_url=self.app.config['CFG_SITE_SECURE_URL'],
)
self.assertStatus(response, 200)
def post(self, resource_id):
"""Upload a file."""
d = Deposition.get(resource_id, user=current_user)
# Bail-out early if not permitted (add_file will also check, but then
# we already uploaded the file)
if not d.authorize('add_file'):
raise ForbiddenAction('add_file', d)
uploaded_file = request.files['file']
filename = secure_filename(
request.form.get('filename') or uploaded_file.filename
)
df = DepositionFile(backend=DepositionStorage(d.id))
if df.save(uploaded_file, filename=filename):
try:
d.add_file(df)
d.save()
except FilenameAlreadyExists as e:
df.delete()
raise e
return d.type.marshal_file(df), 201
def put(self, resource_id, file_id):
"""Update a deposition file - i.e. rename it."""
v = APIValidator()
if not v.validate(request.json, file_schema):
abort(
400,
message="Bad request",
status=400,
errors=map(lambda x: dict(message=x, code=error_codes["validation_error"]), v.errors),
)
d = Deposition.get(resource_id, user=current_user)
df = d.get_file(file_id)
if not d.type.authorize_file(d, df, "update_metadata"):
raise ForbiddenAction("update_metadata", df)
new_name = secure_filename(request.json["filename"])
if new_name != request.json["filename"]:
abort(
400,
message="Bad request",
status=400,
errors=[dict(message="Not a valid filename", code=error_codes["validation_error"])],
)
df.name = new_name
d.save()
return d.type.marshal_file(df)
def put(self, resource_id):
"""Update a deposition."""
d = Deposition.get(resource_id, user=current_user)
self.validate_input(d)
self.process_input(d)
d.save()
return d.marshal()
def put(self, oauth, resource_id):
""" Update a deposition """
d = Deposition.get(resource_id, user=current_user)
self.validate_input(d)
self.process_input(d)
d.save()
return d.marshal()
def post(self, oauth, resource_id):
""" Upload a file """
d = Deposition.get(resource_id, user=current_user)
# Bail-out early if not permitted (add_file will also check, but then
# we already uploaded the file)
if not d.authorize('add_file'):
raise ForbiddenAction('add_file', d)
uploaded_file = request.files['file']
filename = secure_filename(
request.form.get('filename') or uploaded_file.filename
)
df = DepositionFile(backend=DepositionStorage(d.id))
if df.save(uploaded_file, filename=filename):
try:
d.add_file(df)
d.save()
except FilenameAlreadyExists as e:
df.delete()
raise e
return d.type.marshal_file(df), 201
def get(self, oauth, resource_id, file_id):
""" Get a deposition file """
d = Deposition.get(resource_id, user=current_user)
df = d.get_file(file_id)
if df is None:
abort(404, message="File does not exist", status=404)
return d.type.marshal_file(df)
def test_create(self):
"""Test."""
from invenio.ext.login.legacy_user import UserInfo
from invenio.modules.deposit.models import Deposition
user = UserInfo(uid=1)
d = Deposition.create(user)
assert d.type == self.DefaultType
assert Deposition.get(d.id).type == self.DefaultType
d2 = Deposition.create(user, type=self.AnotherType)
assert d2.type == self.AnotherType
assert Deposition.get(d2.id).type == self.AnotherType
# remove the records
Deposition.delete(d)
Deposition.delete(d2)
def put(self, resource_id):
"""Sort files in collection."""
if not isinstance(request.json, list):
abort(
400,
message="Bad request",
status=400,
errors=[dict(message="Expected a list", code=error_codes["validation_error"])],
)
v = APIValidator()
for file_item in request.json:
if not v.validate(file_item, file_schema_list):
abort(
400,
message="Bad request",
status=400,
errors=map(lambda x: dict(message=x, code=error_codes["validation_error"]), v.errors),
)
d = Deposition.get(resource_id, user=current_user)
for file_item in request.json:
if not d.get_file(file_item["id"]):
raise FileDoesNotExists(file_item["id"])
# Sort files raise ForbiddenAction if not authorized
d.sort_files(map(lambda x: x["id"], request.json))
d.save()
return map(lambda f: d.type.marshal_file(f), d.files)
def delete(self, resource_id, file_id):
"""Delete existing deposition file."""
d = Deposition.get(resource_id, user=current_user)
# Sort files raise ForbiddenAction if not authorized
df = d.remove_file(file_id)
if df is None:
abort(404, message="File does not exist", status=404)
df.delete()
d.save()
return "", 204
def delete(self, oauth, resource_id, file_id):
""" Delete existing deposition file """
d = Deposition.get(resource_id, user=current_user)
# Sort files raise ForbiddenAction if not authorized
df = d.remove_file(file_id)
if df is None:
abort(404, message="File does not exist", status=404)
df.delete()
d.save()
return "", 204
def deposition_with_files(files, user_id=None, deposition_id=None):
"""Add very big files to a deposition."""
if deposition_id:
d = Deposition.get(deposition_id)
else:
d = Deposition.create(User.query.get(user_id))
for filepath in files:
with open(filepath, "rb") as fileobj:
filename = os.path.basename(filepath)
df = DepositionFile(backend=DepositionStorage(d.id))
df.save(fileobj, filename=filename)
d.add_file(df)
return d
def put(self, resource_id):
"""Sort files in collection."""
if not isinstance(request.json, list):
abort(
400,
message="Bad request",
status=400,
errors=[
dict(
message="Expected a list",
code=error_codes["validation_error"],
)
],
)
v = APIValidator()
for file_item in request.json:
if not v.validate(file_item, file_schema_list):
abort(
400,
message="Bad request",
status=400,
errors=map(
lambda x: dict(message=x,
code=error_codes["validation_error"]),
v.errors),
)
d = Deposition.get(resource_id, user=current_user)
for file_item in request.json:
if not d.get_file(file_item['id']):
raise FileDoesNotExists(file_item['id'])
# Sort files raise ForbiddenAction if not authorized
d.sort_files(map(lambda x: x['id'], request.json))
d.save()
return map(lambda f: d.type.marshal_file(f), d.files)
def put(self, resource_id, file_id):
"""Update a deposition file - i.e. rename it."""
v = APIValidator()
if not v.validate(request.json, file_schema):
abort(
400,
message="Bad request",
status=400,
errors=map(lambda x: dict(
message=x,
code=error_codes["validation_error"]
), v.errors),
)
d = Deposition.get(resource_id, user=current_user)
df = d.get_file(file_id)
if not d.type.authorize_file(d, df, 'update_metadata'):
raise ForbiddenAction('update_metadata', df)
new_name = secure_filename(request.json['filename'])
if new_name != request.json['filename']:
abort(
400,
message="Bad request",
status=400,
errors=[dict(
message="Not a valid filename",
code=error_codes["validation_error"]
)],
)
df.name = new_name
d.save()
return d.type.marshal_file(df)
def get(self, resource_id):
"""List all drafts."""
d = Deposition.get(resource_id, user=current_user)
return map(lambda x: d.type.marshal_draft(x), d.drafts_list)
def get(self, oauth, resource_id):
""" Get deposition list of files """
d = Deposition.get(resource_id, user=current_user)
return map(lambda f: d.type.marshal_file(f), d.files)
def post(self, oauth, resource_id, action_id):
""" Run an action """
d = Deposition.get(resource_id, user=current_user)
return d.type.api_action(d, action_id)
def put(self, oauth, resource_id, draft_id):
""" Update a deposition draft """
d = Deposition.get(resource_id, user=current_user)
self.validate_input(d, draft_id)
self.process_input(d, draft_id)
d.save()
def get(self, oauth, resource_id, draft_id):
""" Get a deposition draft """
d = Deposition.get(resource_id, user=current_user)
return d.type.marshal_draft(d.get_draft(draft_id))
def get(self, oauth, resource_id):
""" List all drafts """
d = Deposition.get(resource_id, user=current_user)
return map(lambda x: d.type.marshal_draft(x), d.drafts_list)
def get(self, resource_id):
"""Get deposition list of files."""
d = Deposition.get(resource_id, user=current_user)
return map(lambda f: d.type.marshal_file(f), d.files)
def get(self, oauth, resource_id, draft_id):
"""Get a deposition draft."""
d = Deposition.get(resource_id, user=current_user)
return d.type.marshal_draft(d.get_draft(draft_id))
def get(self, oauth, resource_id):
""" Get a deposition """
return Deposition.get(resource_id, user=current_user).marshal()
def deposition_users(depositions):
"""Iterate over deposition users."""
for d in depositions:
yield Deposition.get(d).user_id
def put(self, resource_id, draft_id):
"""Update a deposition draft."""
d = Deposition.get(resource_id, user=current_user)
self.validate_input(d, draft_id)
self.process_input(d, draft_id)
d.save()
def post(self, resource_id, action_id):
"""Run an action."""
d = Deposition.get(resource_id, user=current_user)
return d.type.api_action(d, action_id)
def delete(self, resource_id):
"""Delete existing deposition."""
d = Deposition.get(resource_id, user=current_user)
d.delete()
return "", 204
def get(self, resource_id):
"""Get a deposition."""
return Deposition.get(resource_id, user=current_user).marshal()
def delete(self, oauth, resource_id):
""" Delete existing deposition """
d = Deposition.get(resource_id, user=current_user)
d.delete()
return "", 204
