def test_data_structure_get_by_id_raises_model_error_if_not_found(self):
# Arrange
mock_user = create_mock_user("1")
# Act # Assert
with self.assertRaises(exceptions.ModelError):
curate_data_structure_api.get_by_id(1, mock_user)
def test_curate_data_structure_get_by_id_raises_does_not_exist_error_if_not_found(
self, mock_get):
# Arrange
mock_get.side_effect = exceptions.DoesNotExist("")
mock_user = create_mock_user("1")
# Act # Assert
with self.assertRaises(exceptions.DoesNotExist):
curate_data_structure_api.get_by_id(1, mock_user)
def clear_fields(request):
"""Clear fields of the current form.
Args:
request:
Returns:
"""
try:
# get curate data structure
curate_data_structure_id = request.POST["id"]
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id, request.user)
# generate form
template = template_api.get(str(curate_data_structure.template.id),
request=request)
root_element = generate_form(template.content,
data_structure=curate_data_structure,
request=request)
# save the root element in the data structure
curate_data_structure_api.update_data_structure_root(
curate_data_structure, root_element, request.user)
# renders the form
xsd_form = render_form(request, root_element)
return HttpResponse(json.dumps({"xsdForm": xsd_form}),
content_type="application/javascript")
except Exception as e:
return HttpResponseBadRequest(escape(str(e)))
def clear_fields(request):
"""Clear fields of the current form.
Args:
request:
Returns:
"""
try:
# get curate data structure
curate_data_structure_id = request.POST['id']
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id)
# generate form
root_element = generate_form(curate_data_structure.template.content)
# save the root element in the data structure
curate_data_structure_api.update_data_structure_root(
curate_data_structure, root_element)
# renders the form
xsd_form = render_form(request, root_element)
return HttpResponse(json.dumps({'xsdForm': xsd_form}),
content_type='application/javascript')
except:
return HttpResponseBadRequest()
def test_get_by_id_as_owner_returns_data_structure(self):
data_structure_id = self.fixture.data_structure_1.id
mock_user = create_mock_user(self.fixture.data_structure_1.user)
data_structure = curate_data_structure_api.get_by_id(
data_structure_id, mock_user
)
self.assertTrue(isinstance(data_structure, CurateDataStructure))
def validate_form(request):
"""Validate data present in the form via XML validation.
Args:
request:
Returns:
"""
response_dict = {}
try:
# get curate data structure
curate_data_structure_id = request.POST['id']
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id)
# generate the XML
xml_data = render_xml(
curate_data_structure.data_structure_element_root)
# build trees
xsd_tree = XSDTree.build_tree(curate_data_structure.template.content)
xml_tree = XSDTree.build_tree(xml_data)
# validate XML document
errors = validate_xml_data(xsd_tree, xml_tree)
# FIXME: test xmlParseEntityRef exception: use of & < > forbidden
if errors is not None:
response_dict['errors'] = errors
except Exception, e:
message = e.message.replace('"', '\'')
response_dict['errors'] = message
def cancel_form(request):
"""Cancel current form.
Args:
request:
Returns:
"""
try:
# get curate data structure
curate_data_structure_id = request.POST['id']
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id)
# unlock from database
if curate_data_structure.data is not None:
lock_api.remove_lock_on_object(curate_data_structure.data,
request.user)
curate_data_structure_api.delete(curate_data_structure)
# add success message
messages.add_message(
request, messages.SUCCESS,
get_form_label().capitalize() + ' deleted with success.')
return HttpResponse(json.dumps({}),
content_type='application/javascript')
except:
return HttpResponseBadRequest()
def cancel_form(request):
"""Cancel current form.
Args:
request:
Returns:
"""
try:
# get curate data structure
curate_data_structure_id = request.POST["id"]
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id, request.user)
# unlock from database
if curate_data_structure.data is not None:
lock_api.remove_lock_on_object(curate_data_structure.data,
request.user)
curate_data_structure_api.delete(curate_data_structure, request.user)
# add success message
messages.add_message(
request,
messages.SUCCESS,
get_form_label().capitalize() + " deleted with success.",
)
return HttpResponse(json.dumps({}),
content_type="application/javascript")
except Exception as e:
return HttpResponseBadRequest(
"An unexpected error has occured: %s" % str(e).replace('"', "'"),
content_type="application/javascript",
)
def _get_forms(form_ids, request_user_is_superuser, request_user_id):
""" Get all the forms from the list of ids.
Args:
form_ids:
request_user_is_superuser:
request_user_id:
Returns:
list form
"""
list_form = []
try:
for form_id in form_ids:
# Get the form
form = curate_data_structure_api.get_by_id(form_id)
# Check the rights
_check_rights_document(request_user_is_superuser, request_user_id,
form.user)
list_form.append(form)
except DoesNotExist:
raise Exception('It seems a ' + get_form_label() +
' is missing. Please refresh the page.')
except Exception, e:
raise Exception(e.message)
def save_data(request):
"""Save data - delete curate data structure.
Args:
request:
Returns:
"""
try:
# get curate data structure
curate_data_structure_id = request.POST["id"]
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id, request.user)
# unlock from database
if curate_data_structure.data is not None:
lock_api.remove_lock_on_object(curate_data_structure.data,
request.user)
# generate the XML
xml_data = render_xml(
request, curate_data_structure.data_structure_element_root)
if curate_data_structure.data is not None:
# update existing data
data = curate_data_structure.data
else:
# create new data
data = Data()
data.title = curate_data_structure.name
template = template_api.get(str(curate_data_structure.template.id),
request=request)
data.template = template
data.user_id = str(request.user.id)
# set content
data.xml_content = xml_data
# save data
data = data_api.upsert(data, request)
curate_data_structure_api.delete(curate_data_structure, request.user)
messages.add_message(
request,
messages.SUCCESS,
get_data_label().capitalize() + " saved with success.",
)
except Exception as e:
return HttpResponseBadRequest(str(e).replace('"', "'"),
content_type="application/javascript")
return HttpResponse(json.dumps({"data_id": str(data.id)}),
content_type="application/javascript")
def _start_curate_post(request):
"""Start curate POST request.
Args:
request:
Returns:
"""
template_id = str(request.POST["hidden_value"])
selected_option = request.POST["curate_form"]
user_id = str(request.user.id)
if selected_option == "new" or selected_option == "upload":
if selected_option == "new":
new_form = users_forms.NewForm(request.POST)
if new_form.is_valid():
name = new_form.data["document_name"]
curate_data_structure = CurateDataStructure(
user=user_id, template=template_id, name=name)
else:
raise CurateAjaxError(
"An error occurred during the validation " +
get_form_label())
else:
upload_form = users_forms.UploadForm(request.POST, request.FILES)
if upload_form.is_valid():
xml_file = request.FILES["file"]
xml_data = read_xsd_file(xml_file)
well_formed = is_well_formed_xml(xml_data)
name = xml_file.name
if not well_formed:
raise CurateAjaxError(
"An error occurred during the file upload: the file is "
"not well formed XML")
else:
curate_data_structure = CurateDataStructure(
user=user_id,
template=template_id,
name=name,
form_string=xml_data,
)
else:
raise CurateAjaxError(
"An error occurred during the validation " +
get_form_label())
curate_data_structure_api.upsert(curate_data_structure, request.user)
else:
open_form = users_forms.OpenForm(request.POST)
curate_data_structure = curate_data_structure_api.get_by_id(
open_form.data["forms"], request.user)
url = reverse("core_curate_enter_data", args=(curate_data_structure.id, ))
return HttpResponse(url)
def test_curate_data_structure_get_by_id_return_data_if_found(
self, mock_get):
# Arrange
mock_data_structure = CurateDataStructure(user="******",
template=Template(),
name="name")
mock_get.return_value = mock_data_structure
mock_user = create_mock_user("1")
# Act
result = curate_data_structure_api.get_by_id(1, mock_user)
# Assert
self.assertIsInstance(result, CurateDataStructure)
def save_data(request):
"""Save data - delete curate data structure.
Args:
request:
Returns:
"""
try:
# get curate data structure
curate_data_structure_id = request.POST['id']
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id)
# unlock from database
if curate_data_structure.data is not None:
lock_api.remove_lock_on_object(curate_data_structure.data,
request.user)
# generate the XML
xml_data = render_xml(
curate_data_structure.data_structure_element_root)
if curate_data_structure.data is not None:
# update existing data
data = curate_data_structure.data
else:
# create new data
data = Data()
data.title = curate_data_structure.name
data.template = curate_data_structure.template
data.user_id = str(request.user.id)
# set content
data.xml_content = xml_data
# save data
data_api.upsert(data, request.user)
curate_data_structure_api.delete(curate_data_structure)
messages.add_message(
request, messages.SUCCESS,
get_data_label().capitalize() + ' saved with success.')
except Exception, e:
message = e.message.replace('"', '\'')
return HttpResponseBadRequest(message,
content_type='application/javascript')
def get_object(self, request, pk):
"""Get Curate Data Structure from db
Args:
request: HTTP request
pk: ObjectId
Returns:
Data
"""
try:
return data_structure_api.get_by_id(pk, request.user)
except exceptions.DoesNotExist:
raise Http404
def cancel_changes(request):
"""Cancel changes of the current form.
Args:
request:
Returns:
"""
try:
# get curate data structure
curate_data_structure_id = request.POST["id"]
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id, request.user)
if curate_data_structure.data is not None:
# data already saved, reload from data
xml_data = curate_data_structure.data.xml_content
elif curate_data_structure.form_string is not None:
# form already saved, reload from saved form
xml_data = curate_data_structure.form_string
else:
# no saved data, load new form
xml_data = None
# generate form
template = template_api.get(str(curate_data_structure.template.id),
request=request)
root_element = generate_form(
template.content,
xml_data,
data_structure=curate_data_structure,
request=request,
)
# save the root element in the data structure
curate_data_structure_api.update_data_structure_root(
curate_data_structure, root_element, request.user)
# renders the form
xsd_form = render_form(request, root_element)
return HttpResponse(json.dumps({"xsdForm": xsd_form}),
content_type="application/javascript")
except Exception as e:
return HttpResponseBadRequest(escape(str(e)))
def generate_element(request, curate_data_structure_id):
"""Generate an element absent from the form.
Args:
request:
curate_data_structure_id:
Returns:
"""
try:
element_id = request.POST['id']
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id)
xsd_parser = get_parser()
html_form = xsd_parser.generate_element_absent(
request, element_id, curate_data_structure.template.content)
except Exception, e:
return HttpResponseBadRequest()
def validate_form(request):
"""Validate data present in the form via XML validation.
Args:
request:
Returns:
"""
response_dict = {}
try:
# get curate data structure
curate_data_structure_id = request.POST["id"]
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id, request.user)
# generate the XML
xml_data = render_xml(
request, curate_data_structure.data_structure_element_root)
# build trees
template = template_api.get(str(curate_data_structure.template.id),
request=request)
xsd_tree = XSDTree.build_tree(template.content)
xml_tree = XSDTree.build_tree(xml_data)
# validate XML document
errors = validate_xml_data(xsd_tree, xml_tree, request=request)
if errors is not None:
response_dict["errors"] = errors
except XMLSyntaxError as xml_syntax_error:
response_dict[
"errors"] = "Your XML data is not well formatted. " + str(
xml_syntax_error)
except Exception as e:
message = (str(e).replace('"', "'") if str(e) is not None else
"The current document cannot be validated.")
response_dict["errors"] = message
return HttpResponse(json.dumps(response_dict),
content_type="application/javascript")
def save_form(request):
"""Save the current form in data base. Converts it to XML format first.
Args:
request:
Returns:
"""
try:
# get curate data structure
curate_data_structure_id = request.POST['id']
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id)
# unlock from database
if curate_data_structure.data is not None:
lock_api.remove_lock_on_object(curate_data_structure.data,
request.user)
# generate xml data
xml_data = render_xml(
curate_data_structure.data_structure_element_root)
# update curate data structure data
curate_data_structure.form_string = xml_data
# save data structure
curate_data_structure_api.upsert(curate_data_structure)
# add success message
message = Message(
messages.SUCCESS,
get_form_label().capitalize() + ' saved with success.')
return HttpResponse(json.dumps({
'message': message.message,
'tags': message.tags
}),
content_type='application/json')
except:
return HttpResponseBadRequest()
def cancel_changes(request):
"""Cancel changes of the current form.
Args:
request:
Returns:
"""
try:
# get curate data structure
curate_data_structure_id = request.POST['id']
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id)
if curate_data_structure.data is not None:
# data already saved, reload from data
xml_data = curate_data_structure.data.xml_content
elif curate_data_structure.form_string is not None:
# form already saved, reload from saved form
xml_data = curate_data_structure.form_string
else:
# no saved data, load new form
xml_data = None
# generate form
root_element = generate_form(curate_data_structure.template.content,
xml_data)
# save the root element in the data structure
curate_data_structure_api.update_data_structure_root(
curate_data_structure, root_element)
# renders the form
xsd_form = render_form(request, root_element)
return HttpResponse(json.dumps({'xsdForm': xsd_form}),
content_type='application/javascript')
except:
return HttpResponseBadRequest()
def save_form(request):
"""Save the current form in data base. Converts it to XML format first.
Args:
request:
Returns:
"""
try:
# get curate data structure
curate_data_structure_id = request.POST["id"]
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id, request.user)
# generate xml data
xml_data = render_xml(
request, curate_data_structure.data_structure_element_root)
# update curate data structure data
curate_data_structure.form_string = xml_data
# save data structure
curate_data_structure_api.upsert(curate_data_structure, request.user)
# add success message
message = Message(
messages.SUCCESS,
get_form_label().capitalize() + " saved with success.")
return HttpResponse(
json.dumps({
"message": message.message,
"tags": message.tags
}),
content_type="application/json",
)
except Exception as e:
return HttpResponseBadRequest(escape(str(e)))
def _get_curate_data_structure_by_id(curate_data_structure_id, request):
""" Get the curate data structure by its id.
Args: curate_data_structure_id:
request:
Returns:
"""
# get data structure
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id)
# If not link to a data, only ownership check
if curate_data_structure.data is None:
# check ownership
_check_owner(request, accessed_object=curate_data_structure)
# Check based on the data
else:
# check can write data
_check_can_write_data(request, accessed_object=curate_data_structure)
return curate_data_structure
def generate_choice(request, curate_data_structure_id):
"""Generate a choice branch absent from the form.
Args:
request:
curate_data_structure_id:
Returns:
"""
try:
element_id = request.POST["id"]
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id, request.user)
xsd_parser = get_parser(request=request)
template = template_api.get(str(curate_data_structure.template.id),
request=request)
html_form = xsd_parser.generate_choice_absent(
element_id, template.content, data_structure=curate_data_structure)
except Exception as e:
return HttpResponseBadRequest(escape(str(e)))
return HttpResponse(html_form)
def test_get_by_id_as_anonymous_user_raises_error(self):
data_structure_id = self.fixture.data_structure_1.id
with self.assertRaises(AccessControlError):
curate_data_structure_api.get_by_id(data_structure_id, AnonymousUser())
def test_get_by_id_as_user_non_owner_raises_error(self):
data_structure_id = self.fixture.data_structure_1.id
mock_user = create_mock_user(self.fixture.data_structure_3.user)
with self.assertRaises(AccessControlError):
curate_data_structure_api.get_by_id(data_structure_id, mock_user)
def _start_curate_post(request):
"""Start curate POST request.
Args:
request:
Returns:
"""
try:
template_id = str(request.POST['hidden_value'])
selected_option = request.POST['curate_form']
user_id = str(request.user.id)
if selected_option == "new" or selected_option == "upload":
if selected_option == "new":
new_form = users_forms.NewForm(request.POST)
if new_form.is_valid():
name = new_form.data['document_name']
curate_data_structure = CurateDataStructure(
user=user_id, template=template_id, name=name)
else:
raise exceptions.CurateAjaxError(
'Error occurred during the validation ' +
get_form_label())
else:
try: # check XML data or not?
upload_form = users_forms.UploadForm(
request.POST, request.FILES)
if upload_form.is_valid():
xml_file = request.FILES['file']
xml_file.seek(
0) # put the cursor at the beginning of the file
xml_data = xml_file.read(
) # read the content of the file
well_formed = is_well_formed_xml(xml_data)
name = xml_file.name
if not well_formed:
raise exceptions.CurateAjaxError(
'Uploaded File is not well formed XML')
else:
curate_data_structure = CurateDataStructure(
user=user_id,
template=template_id,
name=name,
form_string=xml_data)
else:
raise exceptions.CurateAjaxError(
'Error occurred during the validation ' +
get_form_label())
except Exception as e:
raise exceptions.CurateAjaxError(
'Error during file uploading')
curate_data_structure_api.upsert(curate_data_structure)
else:
open_form = users_forms.OpenForm(request.POST)
curate_data_structure = curate_data_structure_api.get_by_id(
open_form.data['forms'])
url = reverse("core_curate_enter_data",
args=(curate_data_structure.id, ))
return HttpResponse(url)
except Exception as e:
raise exceptions.CurateAjaxError(e.message)
def _init_prefix_and_record(self, data, curate_data_structure_id, user):
"""Helper function to determine prefix and record from a module
Args:
data:
curate_data_structure_id:
user:
Returns:
"""
from core_linked_records_app.utils.dict import get_dict_value_from_key_list
from core_linked_records_app.utils.providers import ProviderManager
# If data is not empty and linked records installed, get record name and
# prefix.
record_host_pid_url = None
settings_host_pid_url = (
ProviderManager().get(self.pid_settings["system"]).provider_lookup_url
)
try:
data_split = data.split("/")
record_host_pid_url = "/".join(data_split[:-2])
self.default_value = data_split[-1].strip(" ")
self.default_prefix = data_split[-2]
assert record_host_pid_url == settings_host_pid_url
assert self.default_prefix in self.pid_settings["prefixes"]
# Check the record name match the expected format.
record_format_match = match(
r"^(%s|)$" % self.pid_settings["format"], self.default_value
)
assert record_format_match is not None
# Check that the URL is not already assigned.
record_response = send_get_request(
"%s?format=json" % data, allow_redirects=False
)
# Retrieve curate datastructure associated with the current form. Used
# to check if the data being edited is the same as the one with the
# assigned PID.
curate_data_structure_object = curate_data_structure_api.get_by_id(
curate_data_structure_id, user
)
assert record_response.status_code == 404 or (
curate_data_structure_object["data"] is not None
and get_dict_value_from_key_list(
curate_data_structure_object["data"]["dict_content"],
self.pid_settings["xpath"].split("."),
)
== data
)
except IndexError:
self.default_prefix = None
self.default_value = None
self.error_data = data
except AssertionError:
if record_host_pid_url != settings_host_pid_url:
self.default_prefix = None
self.default_value = None
self.error_data = data
finally:
return data if self.default_value else ""
