def _save_template_version(request, assets, context, template_version_manager):
"""Save a template version.
Args:
request:
assets:
context:
template_version_manager:
Returns:
"""
# get the file from the form
xsd_file = request.FILES['xsd_file']
# read the content of the file
xsd_data = read_xsd_file(xsd_file)
try:
template = Template(filename=xsd_file.name, content=xsd_data)
template_version_manager_api.insert(template_version_manager, template)
return HttpResponseRedirect(
reverse("admin:core_main_app_manage_template_versions",
kwargs={
'version_manager_id': str(template_version_manager.id)
}))
except exceptions.XSDError, xsd_error:
return handle_xsd_errors(request, assets, context, xsd_error, xsd_data,
xsd_file.name)
def _save_template(request, assets, context):
"""Save a template.
Args:
request:
assets:
context:
Returns:
"""
# get the schema name
name = request.POST['name']
# get the file from the form
xsd_file = request.FILES['upload_file']
# read the content of the file
xsd_data = read_xsd_file(xsd_file)
try:
template = Template(filename=xsd_file.name, content=xsd_data)
template_version_manager = TemplateVersionManager(title=name)
template_version_manager_api.insert(template_version_manager, template)
return HttpResponseRedirect(reverse("admin:core_main_app_templates"))
except exceptions.XSDError, xsd_error:
return handle_xsd_errors(request, assets, context, xsd_error, xsd_data, xsd_file.name)
def _save_template(request, assets, context):
"""Save a template.
Args:
request:
assets:
context:
Returns:
"""
# get the schema name
name = request.POST['name']
# get the file from the form
xsd_file = request.FILES['upload_file']
# read the content of the file
xsd_data = read_xsd_file(xsd_file)
try:
template = Template(filename=xsd_file.name, content=xsd_data)
template_version_manager = TemplateVersionManager(title=name)
template_version_manager_api.insert(template_version_manager, template)
return HttpResponseRedirect(reverse("admin:core_main_app_templates"))
except exceptions.XSDError as xsd_error:
return handle_xsd_errors(request, assets, context, xsd_error, xsd_data,
xsd_file.name)
except exceptions.NotUniqueError:
context['errors'] = html_escape(
"A template with the same name already exists. Please choose another name."
)
return _upload_template_response(request, assets, context)
except Exception as e:
context['errors'] = html_escape(str(e))
return _upload_template_response(request, assets, context)
def _add_template():
"""Add the registry template.
Returns:
"""
xsd_filepath = REGISTRY_XSD_FILEPATH
xsd_filename = REGISTRY_XSD_FILENAME
if xsd_filename == "":
raise Exception(
"Please configure the REGISTRY_XSD_FILENAME setting in your project."
)
if xsd_filepath == "":
raise Exception(
"Please configure the REGISTRY_XSD_FILEPATH setting in your project."
)
try:
version_manager_api.get_active_global_version_manager_by_title(
xsd_filename)
except exceptions.DoesNotExist:
default_xsd_path = finders.find(xsd_filepath)
xsd_data = read_file_content(default_xsd_path)
template = Template(filename=xsd_filename, content=xsd_data)
template_version_manager = TemplateVersionManager(title=xsd_filename)
template_version_manager_api.insert(template_version_manager, template)
except Exception as e:
logger.error("Impossible to add the template: {0}".format(str(e)))
def create(self, validated_data):
"""
Create and return a new `Template` instance, given the validated data.
"""
template_object = Template(
filename=validated_data["filename"],
content=validated_data["content"],
user=validated_data["user"],
)
template_version_manager_object = validated_data["template_version_manager"]
# load dependencies
dependencies_dict = load_dependencies(validated_data)
# Update the content of the template with dependencies
init_template_with_dependencies(
template_object, dependencies_dict, request=self.context["request"]
)
# Create the template and its template version manager
template_version_manager_api.insert(
template_version_manager_object,
template_object,
request=self.context["request"],
)
return template_object
def resolve_dependencies(request):
"""Resolve import/includes to avoid local references.
Args:
request:
Returns:
"""
try:
# Get the parameters
name = request.POST.get('name', None)
version_manager_id = request.POST.get('version_manager_id', '')
filename = request.POST['filename']
xsd_content = request.POST['xsd_content']
schema_locations = request.POST.getlist('schemaLocations[]')
dependencies = request.POST.getlist('dependencies[]')
# create new object
template = Template(filename=filename,
content=_get_xsd_content_from_html(xsd_content))
init_template_with_dependencies(
template, _get_dependencies_dict(schema_locations, dependencies))
# get the version manager or create a new one
if version_manager_id != '':
template_version_manager = version_manager_api.get(
version_manager_id)
else:
template_version_manager = TemplateVersionManager(title=name)
template_version_manager_api.insert(template_version_manager, template)
except Exception, e:
return HttpResponseBadRequest(e.message)
def test_insert_global_template_as_user_raises_access_control_error(self):
mock_request = create_mock_request(user=self.user1)
with self.assertRaises(AccessControlError):
template_vm_api.insert(
self.fixture.global_tvm,
self.fixture.global_template,
request=mock_request,
)
def test_create_version_manager_raises_exception_if_error_in_create_template(self, mock_save):
# Arrange
template_filename = "schema.xsd"
template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>"
template = _create_template(template_filename, template_content)
mock_version_manager = _create_mock_template_version_manager(title="Schema")
mock_save.side_effect = django_exceptions.ValidationError("")
# Act + Assert
with self.assertRaises(django_exceptions.ValidationError):
version_manager_api.insert(mock_version_manager, template)
def save_template(request):
"""Save the current template in the database.
Args:
request:
Returns:
"""
try:
template_name = request.POST['templateName']
xsd_string = request.session['newXmlTemplateCompose']
response_dict = {}
try:
# Build XSD tree
xsd_tree = XSDTree.build_tree(xsd_string)
# validate the schema
error = main_xml_utils.validate_xml_schema(xsd_tree)
if error is not None:
return _error_response('This is not a valid XML schema. ' +
error)
except Exception, e:
return _error_response('This is not a valid XML schema. ' +
e.message)
# get list of dependencies
dependencies = _get_dependencies_ids(
request.session["includedTypesCompose"])
try:
# create template version manager
template_version_manager = TemplateVersionManager(
title=template_name, user=str(request.user.id))
# create template
template = Template(filename=template_name,
content=xsd_string,
dependencies=dependencies)
# save template in database
template_version_manager_api.insert(template_version_manager,
template)
except exceptions.NotUniqueError:
return HttpResponseBadRequest(
"A template with the same name already exists. Please choose another name."
)
except Exception, e:
return _error_response(e.message)
def insert_templates(self):
saved_templates = []
saved_template_version = []
list_templates = OaiPmhMock.mock_template()
for template in list_templates:
# Create template version manager
template_version_manager = TemplateVersionManager(
title='default_chemical_element_type')
template_version_manager_api.insert(template_version_manager,
template)
saved_template_version.append(template_version_manager)
saved_templates.append(template.save())
self.templates = saved_templates
self.template_version = saved_template_version
def test_create_version_manager_raises_exception_if_error_in_create_version_manager(self, mock_save_template,
mock_save_version_manager,
mock_delete_template):
# Arrange
template_filename = "Schema"
template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>"
template = _create_template(template_filename, template_content)
mock_save_template.return_value = template
version_manager = _create_template_version_manager(title="Schema")
mock_save_version_manager.side_effect = django_exceptions.ValidationError("")
mock_delete_template.return_value = None
# Act + Assert
with self.assertRaises(ModelError):
version_manager_api.insert(version_manager, template)
def test_insert_manager_raises_api_error_if_title_already_exists(self, mock_version_manager_save,
mock_template_save,
mock_template_delete):
# Arrange
template_filename = "schema.xsd"
template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>"
template = _create_template(template_filename, template_content)
mock_template_save.return_value = template
mock_template_delete.return_value = None
mock_version_manager = _create_template_version_manager(title="Schema")
mock_version_manager_save.side_effect = mongoengine_errors.NotUniqueError("")
# Act + Assert
with self.assertRaises(NotUniqueError):
version_manager_api.insert(mock_version_manager, template)
def test_insert_raises_exception_if_error_in_create_template(
self, mock_save_template):
# Arrange
mock_user = create_mock_user("1", is_superuser=True)
mock_request = create_mock_request(mock_user)
template_filename = "schema.xsd"
template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>"
template = _create_template(template_filename, template_content)
mock_save_template.side_effect = django_exceptions.ValidationError("")
mock_version_manager = _create_mock_template_version_manager()
# Act + Assert
with self.assertRaises(django_exceptions.ValidationError):
version_manager_api.insert(mock_version_manager,
template,
request=mock_request)
def _save_template_version(request, assets, context, template_version_manager):
"""Save a template version.
Args:
request:
assets:
context:
template_version_manager:
Returns:
"""
try:
# get the file from the form
xsd_file = request.FILES["xsd_file"]
# read the content of the file
xsd_data = read_xsd_file(xsd_file)
template = Template(filename=xsd_file.name, content=xsd_data)
template_version_manager_api.insert(template_version_manager,
template,
request=request)
# create the fragment url with all the version of the template (minus the new template)
version_manager_string = ""
for version in template_version_manager.versions:
if version != str(template.id):
current_version_string = (version if version_manager_string
== "" else f",{version}")
version_manager_string += current_version_string
# add the fragment data to the url
fragment = f"#from={version_manager_string}&to={template.id}"
return HttpResponseRedirect(
reverse("admin:core_main_app_data_migration") + fragment)
except exceptions.XSDError as xsd_error:
return handle_xsd_errors(request, assets, context, xsd_error, xsd_data,
xsd_file.name)
except Exception as e:
context["errors"] = html_escape(str(e))
return _upload_template_response(request, assets, context)
def resolve_dependencies(request):
"""Resolve import/includes to avoid local references.
Args:
request:
Returns:
"""
try:
# Get the parameters
name = request.POST.get("name", None)
version_manager_id = request.POST.get("version_manager_id", "")
filename = request.POST["filename"]
xsd_content = request.POST["xsd_content"]
schema_locations = request.POST.getlist("schemaLocations[]")
dependencies = request.POST.getlist("dependencies[]")
# create new object
template = Template(
filename=filename, content=_get_xsd_content_from_html(xsd_content)
)
init_template_with_dependencies(
template,
_get_dependencies_dict(schema_locations, dependencies),
request=request,
)
# get the version manager or create a new one
if version_manager_id != "":
template_version_manager = version_manager_api.get(
version_manager_id, request=request
)
else:
template_version_manager = TemplateVersionManager(title=name)
template_version_manager_api.insert(
template_version_manager, template, request=request
)
except Exception as e:
return HttpResponseBadRequest(escape(str(e)))
return HttpResponse(json.dumps({}), content_type="application/javascript")
def create(self, validated_data):
"""
Create and return a new `Template` instance, given the validated data.
"""
template_object = Template(filename=validated_data['filename'],
content=validated_data['content'])
template_version_manager_object = validated_data[
'template_version_manager']
# load dependencies
dependencies_dict = load_dependencies(validated_data)
# Update the content of the template with dependencies
init_template_with_dependencies(template_object, dependencies_dict)
# Create the template and its template version manager
template_version_manager_api.insert(template_version_manager_object,
template_object)
return template_object
def _set_xsd_template(xsd_filename, xsd_data):
"""Register XSD template to Django.
Args:
xsd_filename:
xsd_data:
Returns:
"""
try:
template = Template(filename=xsd_filename, content=xsd_data)
template_version_manager = TemplateVersionManager(title=xsd_filename)
template_version_manager_api.insert(template_version_manager, template)
logger.info("XSD template:" + xsd_filename +
" registered as a template.")
except exceptions.CoreError as e:
logger.info(xsd_filename + " didn't registered as a template :" +
str(e))
except exceptions.NotUniqueError as e:
logger.info(xsd_filename + " didn't registered as a template :" +
str(e))
except Exception as e:
logger.info(xsd_filename + " didn't registered as a template :" +
str(e))
def test_insert_returns_template_version(self, mock_save_template_version_manager, mock_save_template, mock_insert):
# Arrange
template_filename = "Schema"
template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>"
template = _create_template(template_filename, template_content)
mock_save_template.return_value = template
version_manager = _create_template_version_manager()
mock_save_template_version_manager.return_value = version_manager
mock_insert.return_value = version_manager
# Act
result = version_manager_api.insert(version_manager, template)
# Assert
self.assertIsInstance(result, TemplateVersionManager)
def test_create_version_manager_returns_version_manager(
self, mock_save_template, mock_save_template_version_manager):
# Arrange
mock_user = create_mock_user("1", is_superuser=True)
mock_request = create_mock_request(mock_user)
template_filename = "schema.xsd"
template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>"
template = _create_template(template_filename, template_content)
mock_save_template.return_value = template
version_manager = _create_template_version_manager(title="Schema")
mock_save_template_version_manager.return_value = version_manager
# Act
result = version_manager_api.insert(version_manager,
template,
request=mock_request)
# Assert
self.assertIsInstance(result, TemplateVersionManager)
def save_template(request):
"""Save the current template in the database.
Args:
request:
Returns:
"""
try:
template_name = request.POST["templateName"]
xsd_string = request.session["newXmlTemplateCompose"]
response_dict = {}
try:
# Build XSD tree
xsd_tree = XSDTree.build_tree(xsd_string)
# validate the schema
error = main_xml_utils.validate_xml_schema(xsd_tree,
request=request)
if error is not None:
return _error_response("This is not a valid XML schema. " +
error)
except Exception as e:
return _error_response("This is not a valid XML schema. " +
escape(str(e)))
# get list of dependencies
dependencies = _get_dependencies_ids(
request.session["includedTypesCompose"], request=request)
try:
# create template version manager
template_version_manager = TemplateVersionManager(
title=template_name, user=str(request.user.id))
# create template
template = Template(
filename=template_name,
content=xsd_string,
dependencies=dependencies,
user=str(request.user.id),
)
# save template in database
template_version_manager_api.insert(template_version_manager,
template,
request=request)
except exceptions.NotUniqueError:
return HttpResponseBadRequest(
"A template with the same name already exists. Please choose another name."
)
except Exception as e:
return _error_response(escape(str(e)))
return HttpResponse(json.dumps(response_dict),
content_type="application/javascript")
except Exception as e:
return HttpResponseBadRequest(escape(str(e)),
content_type="application/javascript")
def test_insert_global_template_as_staff_saves(self):
mock_request = create_mock_request(user=self.staff_user1)
template_vm_api.insert(self.fixture.global_tvm,
self.fixture.global_template,
request=mock_request)
def test_insert_own_template_as_superuser_saves(self):
mock_request = create_mock_request(user=self.superuser1)
template_vm_api.insert(self.fixture.user1_tvm,
self.fixture.user1_template,
request=mock_request)
