def _get_template():
template = Template()
template.id_field = 1
xsd = '<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">' \
'<xs:element name="tag"></xs:element></xs:schema>'
template.content = xsd
return template
def _get_template():
template = Template()
template.pk = 1
xsd = ("<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>"
"<xs:element name='tag'></xs:element></xs:schema>")
template.content = xsd
return template
def generate_template_xsl_rendering_collection(self):
"""Generate a TemplateXslRendering collection.
Returns:
"""
# NOTE: no real file to avoid using unsupported GridFS mock
self.template_1 = Template(filename="template_1.xsd",
content="content1",
hash="hash1").save()
self.template_2 = Template(filename="template_2.xsd",
content="content2",
hash="hash2").save()
self.template_xsl_rendering_1 = TemplateXslRendering(
template=str(self.template_1.id)).save()
self.xsl_transformation_3 = XslTransformation(
name="xsl_transformation_3",
filename="xsl_transformation_3",
content="content_3",
).save()
self.template_xsl_rendering_2 = TemplateXslRendering(
template=str(self.template_2.id),
default_detail_xslt=str(self.xsl_transformation_3.id),
list_detail_xslt=[str(self.xsl_transformation_3.id)],
).save()
self.template_xsl_rendering_collection = [
self.template_xsl_rendering_1,
self.template_xsl_rendering_2,
]
def generate_template_collection(self):
"""Generate a Template Collections.
Returns:
"""
xsd = (
'<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">'
'<xs:element name="tag"></xs:element></xs:schema>'
)
self.user1_template = Template(
content=xsd,
hash="user1_template_hash",
filename="user1_template.xsd",
user="******",
).save()
self.user2_template = Template(
content=xsd,
hash="user2_template_hash",
filename="user2_template.xsd",
user="******",
).save()
self.global_template = Template(
content=xsd,
hash="global_template_hash",
filename="global_template.xsd",
user=None,
).save()
self.template_collection = [
self.user1_template,
self.user2_template,
self.global_template,
]
def create_and_save_template():
template = Template(
filename="Schema",
content=
"<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>",
hash="",
)
template.save()
return template
def create_template(content):
"""Get template
Returns:
"""
template = Template()
template.filename = "schema.json"
template.content = content
return template
def insert_data(self):
"""Insert a set of Templates and Template Version Managers.
Returns:
"""
# Make a connexion with a mock database
xsd = ('<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">'
'<xs:element name="tag"></xs:element></xs:schema>')
self.user1_template = Template(filename="template1.xsd",
content=xsd,
hash="hash1",
user="******").save()
self.user2_template = Template(filename="template2.xsd",
content=xsd,
hash="hash2",
user="******").save()
self.global_template = Template(filename="global_template.xsd",
content=xsd,
hash="global hash",
user=None).save()
self.user1_tvm = TemplateVersionManager(
title="template 1",
user="******",
versions=[
str(self.user1_template.id),
],
current=str(self.user1_template.id),
is_disabled=False,
disabled_versions=[],
).save()
self.user2_tvm = TemplateVersionManager(
title="template 2",
user="******",
versions=[str(self.user2_template.id)],
current=str(self.user2_template.id),
is_disabled=False,
disabled_versions=[],
).save()
self.global_tvm = TemplateVersionManager(
title="global template",
user=None,
versions=[str(self.global_template.id)],
current=str(self.global_template.id),
is_disabled=False,
disabled_versions=[],
).save()
self.template_vm_collection = [
self.user1_tvm, self.user2_tvm, self.global_tvm
]
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 _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_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 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 get_all_templates():
"""Return all templates
Returns:
"""
return Template.get_all(is_cls=True)
def get_all(request, is_cls=True):
"""List all templates.
Returns:
"""
return Template.get_all(is_cls, users=get_accessible_owners(request=request))
def get_all(is_cls=True):
"""List all templates.
Returns:
"""
return Template.get_all(is_cls)
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 _create_template(filename="", content=""):
"""
Returns a template
:param filename:
:param content:
:return:
"""
return Template(id=ObjectId(), filename=filename, content=content)
def mock_template(version=""):
with open(
join(DUMP_OAI_PMH_TEST_PATH,
"template{0}.json".format(version))) as f:
data = f.read()
data_json = json.loads(data)
list_templates = [Template(**x) for x in data_json]
return list_templates
def insert_registry_schema(xsd_filename, xsd_content):
# Check if schema is valid
is_schema_valid(xsd_content)
template = Template(
filename=xsd_filename, hash=get_hash(xsd_content), content=xsd_content
).save()
template_version_manager = TemplateVersionManager(title=xsd_filename)
# save the template in database
try:
from core_main_app.components.version_manager import api as version_manager_api
# insert the initial template in the version manager
template_version_manager.insert(template)
template_version_manager.set_current_version(template)
# insert the version manager in database
template_version_manager.save_version_manager()
# get template display name
display_name = get_latest_version_name(template_version_manager)
# update saved template
template.display_name = display_name
template.save()
# return version manager
return template_version_manager
except Exception as e:
template.delete()
raise e
def get(template_id):
"""Get a template.
Args:
template_id:
Returns:
"""
return Template.get_by_id(template_id)
def insert_data(self):
"""Insert a set of Templates and Template Version Managers.
Returns:
"""
# Make a connexion with a mock database
self.template_1_1 = Template(
filename="template1_1.xsd", content="content1_1", hash="hash1_1"
).save()
self.template_1_2 = Template(
filename="template1_2.xsd", content="content1_2", hash="hash1_2"
).save()
self.template_1_3 = Template(
filename="template1_3.xsd", content="content1_3", hash="hash1_3"
).save()
self.template_2_1 = Template(
filename="template2_1.xsd", content="content2_1", hash="hash2_1"
).save()
self.template_vm_1 = TemplateVersionManager(
title="template 1",
user=None,
versions=[
str(self.template_1_1.id),
str(self.template_1_2.id),
str(self.template_1_3.id),
],
current=str(self.template_1_3.id),
is_disabled=False,
disabled_versions=[str(self.template_1_2.id)],
).save()
self.template_vm_2 = TemplateVersionManager(
title="template 2",
user="******",
versions=[str(self.template_2_1.id)],
current=str(self.template_2_1.id),
is_disabled=False,
disabled_versions=[],
).save()
self.template_vm_collection = [self.template_vm_1, self.template_vm_2]
def test_anonymous_returns_http_200(self, template_get_by_id):
template_get_by_id.return_value = Template(content='test',
filename='test.txt')
response = RequestMock.do_request_get(
template_views.TemplateDownload.as_view(),
None,
param={'pk': self.fake_id})
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_anonymous_returns_http_403(self, template_get_by_id):
template_get_by_id.return_value = Template(content="test",
filename="test.txt")
response = RequestMock.do_request_get(
template_views.TemplateDownload.as_view(),
None,
param={"pk": self.fake_id})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def get_all_by_id_list(template_id_list):
""" Returns all template with id in list
Args:
template_id_list:
Returns:
"""
return Template.get_all_by_id_list(template_id_list)
def get_template_by_id(template_id):
"""Get template by id
Args:
template_id:
Returns:
"""
return Template.get_by_id(template_id)
def test_anonymous_returns_http_403(self, template_serializer_data,
template_get_by_id):
template_get_by_id.return_value = Template(user=None)
template_serializer_data.return_value = True
response = RequestMock.do_request_get(
template_views.TemplateDetail.as_view(),
None,
param={"pk": self.fake_id})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_get_by_template_hash_raises_exception_if_object_does_not_exist(self, mock_get_by_template_id,
mock_get_all_by_hash):
# Arrange
mock_absent_hash = "dummy_hash"
mock_get_all_by_hash.return_value = [Template()]
mock_get_by_template_id.side_effect = exceptions.DoesNotExist("Error.")
# Act + Assert
with self.assertRaises(exceptions.DoesNotExist):
template_xsl_rendering_api.get_by_template_hash(mock_absent_hash)
def test_get_by_template_hash_raises_exception_if_internal_error(self, mock_get_by_template_id,
mock_get_all_by_hash):
# Arrange
mock_absent_hash = "dummy_hash"
mock_get_all_by_hash.return_value = [Template()]
mock_get_by_template_id.side_effect = exceptions.ModelError("Error.")
# Act + Assert
with self.assertRaises(exceptions.ModelError):
template_xsl_rendering_api.get_by_template_hash(mock_absent_hash)
def get_all_by_hash(template_hash):
""" Return all template having the given hash.
Args:
template_hash: Template hash.
Returns:
List of Template instance.
"""
return Template.get_all_by_hash(template_hash)
def get_all_by_hash_list(template_hash_list):
""" Return all template having the given hash list.
Args:
template_hash_list: Template hash list.
Returns:
List of Template instance.
"""
return Template.get_all_by_hash_list(template_hash_list)
