def create(self, validated_data):
"""
Create and return a new `Data` instance, given the validated data.
"""
# Create data
instance = Data(
template=validated_data["template"],
workspace=validated_data["workspace"]
if "workspace" in validated_data
else None,
title=validated_data["title"],
user_id=str(self.context["request"].user.id),
)
# Get template
template_api.get(instance.template.id, request=self.context["request"])
# Set xml content
instance.xml_content = validated_data["xml_content"]
# Save the data and retrieve the inserted object
inserted_data = data_api.upsert(instance, self.context["request"])
# Encode the response body
inserted_data.xml_content = inserted_data.xml_content.encode("utf-8")
return inserted_data
def test_template_get_raises_exception_if_object_does_not_exist(self, mock_get_by_id):
# Arrange
mock_absent_id = ObjectId()
mock_get_by_id.side_effect = mongoengine_errors.DoesNotExist
# Act + Assert
with self.assertRaises(mongoengine_errors.DoesNotExist):
template_api.get(mock_absent_id)
def test_get_any_template_as_superuser_returns_template(self):
mock_request = create_mock_request(user=self.superuser1)
template = template_api.get(self.fixture.user1_template.id,
request=mock_request)
self.assertEqual(template, self.fixture.user1_template)
template = template_api.get(self.fixture.user2_template.id,
request=mock_request)
self.assertEqual(template, self.fixture.user2_template)
template = template_api.get(self.fixture.global_template.id,
request=mock_request)
self.assertEqual(template, self.fixture.global_template)
def _save_template_xslt(self, request):
"""Save a template xslt rendering.
Args:
request: Request.
"""
try:
# Get the list xslt instance
try:
list_xslt = xslt_transformation_api.get_by_id(request.POST.get('list_xslt'))
except (Exception, exceptions.DoesNotExist):
list_xslt = None
# Get the detail xslt instance
try:
detail_xslt = xslt_transformation_api.get_by_id(request.POST.get('detail_xslt'))
except (Exception, exceptions.DoesNotExist):
detail_xslt = None
template_xsl_rendering_api.add_or_delete(template_xsl_rendering_id=request.POST.get('id'),
template_id=request.POST.get('template'),
list_xslt=list_xslt, detail_xslt=detail_xslt)
template = template_api.get(request.POST.get('template'))
# Get template information (version)
version_manager = version_manager_api.get_from_version(template)
return HttpResponseRedirect(reverse(self.save_redirect, args=[version_manager.id]))
except Exception, e:
self.context.update({'errors': html_escape(e.message)})
return self.rendering(request, self.template_name, context=self.context)
def get_xsd(request, title, version_number):
""" Page that allows to retrieve an XML Schema by its title and version number.
Args:
request: Request.
title: Schema title.
version_number: Version of the schema.
Returns:
Flatten Schema.
"""
try:
template_version = version_manager_api.get_active_global_version_manager_by_title(
title)
template = template_api.get(
version_manager_api.get_version_by_number(template_version,
int(version_number)))
flatten = XSDFlattenerDatabaseOrURL(template.content.encode('utf-8'))
content_encoded = flatten.get_flat()
file_obj = StringIO(content_encoded)
return HttpResponse(file_obj, content_type='text/xml')
except (exceptions.DoesNotExist, exceptions.ModelError, Exception):
return HttpResponseBadRequest(
'Impossible to retrieve the schema with the given name and version.'
)
def get_xsd(request, title, version_number):
"""Page that allows to retrieve an XML Schema by its title and version
number.
Args:
request: Request.
title: Schema title.
version_number: Version of the schema.
Returns:
Flatten Schema.
"""
try:
template_version = (
version_manager_api.get_active_global_version_manager_by_title(
title, request=request))
template = template_api.get(
version_manager_api.get_version_by_number(template_version,
int(version_number),
request=request),
request=request,
)
content_encoded = XSDFlattenerDatabaseOrURL(
template.content, request=request).get_flat()
file_obj = StringIO(content_encoded)
return HttpResponse(file_obj, content_type="text/xml")
except Exception as e:
return HttpResponseBadRequest(
"Impossible to retrieve the schema with the given name and "
"version: %s" % escape(str(e)))
def oxygen_viewer(request, pk):
"""
Args:
request:
pk:
Returns:
"""
template = template_api.get(pk)
file_name_html = template.filename.replace('.xsd', '.html')
# find a file under static
url_file = finders.find(
join('core_schema_viewer_app', 'common', 'oxygen', file_name_html))
if url_file:
# render a file under templates
return django_render(
request, "core_schema_viewer_app/common/oxygen/" + file_name_html)
else:
message = "The oxygen documentation file associated to the request template is not available. " \
"Please contact your administrator for further information."
messages.add_message(request, messages.WARNING, message)
return redirect(reverse("core_schema_viewer_index"))
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 _fields_to_query(form_values, template_id,
get_dot_notation_to_element_func, use_wildcard):
"""Takes values from the html tree and creates a query from them
Args:
form_values:
template_id:
use_wildcard:
get_dot_notation_to_element_func:
Returns:
"""
# get template
template = template_api.get(template_id)
# get namespaces
namespaces = get_namespaces(template.content)
# get default prefix
default_prefix = get_default_prefix(namespaces)
query = dict()
for field in form_values:
bool_comp = field['operator']
is_not = bool_comp == 'NOT'
element_type = field.get('type', None)
# get element value
value = get_element_value(field)
# get comparison operator
comparison = get_element_comparison(field)
element_id = field['id']
if element_type == "query":
try:
saved_query = saved_query_api.get_by_id(element_id)
except DoesNotExist:
raise MongoQueryException(
"The saved query does not exist anymore.")
criteria = build_query_criteria(json.loads(saved_query.query),
is_not)
else:
data_structure_element = data_structure_element_api.get_by_id(
element_id)
element = get_dot_notation_to_element_func(data_structure_element,
namespaces)
criteria = build_criteria(element, comparison, value, element_type,
default_prefix, is_not, use_wildcard)
if bool_comp == 'OR':
query = build_or_criteria(query, criteria)
elif bool_comp == 'AND':
query = build_and_criteria(query, criteria)
else:
if form_values.index(field) == 0:
query.update(criteria)
else:
query = build_and_criteria(query, criteria)
return query
def get_dependency_content(self, uri):
""" Get the content of the dependency from the database or from the URL. Try to get the content from the
database first and then try to download it from the provided URI.
Args:
uri: Content URI.
Returns:
Content.
"""
# parse url
url = urlparse(uri)
# get pattern to match a template download url
pattern = get_template_download_pattern()
# match url
match = pattern.match(url.path)
# if match
if match:
try:
# get pk from match
object_id = match.group('pk')
# get template object using pk
template = template_api.get(object_id)
# get template content
content = template.content
except (exceptions.DoesNotExist, exceptions.ModelError, Exception):
content = super(XSDFlattenerDatabaseOrURL,
self).get_dependency_content(uri)
else:
content = super(XSDFlattenerDatabaseOrURL,
self).get_dependency_content(uri)
return content
def _associated_templates_post(request):
""" associated templates modal POST
Args:
request:
Returns:
"""
try:
form = AssociatedTemplatesForm(request.POST)
if form.is_valid():
templates = request.POST.getlist('templates_manager', [])
exporter_id = request.POST.get('id', None)
if exporter_id is not None:
exporter = exporter_api.get_by_id(exporter_id)
template_id_list = [
template_api.get(template_id) for template_id in templates
]
exporter.templates = template_id_list
exporter_api.upsert(exporter)
return HttpResponse(json.dumps({}),
content_type='application/javascript')
else:
return HttpResponseBadRequest(
'Bad entries. Please check your entries')
except Exception, e:
return HttpResponseBadRequest(e.message,
content_type='application/javascript')
def _save_custom_resources(self, request, template_id):
"""Saves an XSLT.
Args:
request: Request.
template_id
"""
try:
# get the template
template = template_api.get(template_id, request=request)
# get the file from the form
upload_file = request.FILES["json_file"].read().decode("utf-8")
data = json.loads(upload_file)
custom_resource_api.replace_custom_resources_by_template(
template, data)
return HttpResponseRedirect(
reverse("admin:core_main_registry_app_custom_registry"))
except Exception as e:
self.context.update({"errors": html_escape(str(e))})
return admin_render(request,
self.template_name,
context=self.context)
def update_user_input(request):
"""Updates the user input of the query builder according to the type of the selected element
Args:
request:
Returns:
"""
from_element_id = request.POST['elementID']
template_id = request.POST['templateID']
# get schema element
data_structure_element = data_structure_element_api.get_by_id(
from_element_id)
# get template
template = template_api.get(template_id)
# convert xml path to mongo dot notation
namespaces = get_namespaces(template.content)
default_prefix = get_default_prefix(namespaces)
element_type = data_structure_element.options['type']
user_inputs = get_user_inputs(element_type, data_structure_element,
default_prefix)
response_dict = {'userInputs': user_inputs, 'element_type': element_type}
return HttpResponse(json.dumps(response_dict),
content_type='application/javascript')
def generate_choice(request, explore_data_structure_id):
"""Generate a choice branch absent from the form.
Args:
request:
explore_data_structure_id:
Returns:
"""
try:
element_id = request.POST["id"]
explore_data_structure = explore_data_structure_api.get_by_id(
explore_data_structure_id)
template = template_api.get(str(explore_data_structure.template.id),
request=request)
xsd_parser = get_parser(request=request)
html_form = xsd_parser.generate_choice_absent(
element_id,
template.content,
data_structure=explore_data_structure,
renderer_class=CustomCheckboxRenderer,
)
except Exception as e:
return HttpResponseBadRequest(
"An unexpected error occurred: %s" % escape(str(e)),
content_type="application/javascript",
)
return HttpResponse(html_form)
def _associated_templates_post(request):
"""associated templates modal POST
Args:
request:
Returns:
"""
form = AssociatedTemplatesForm(request.POST, request=request)
if form.is_valid():
templates = request.POST.getlist("templates_manager", [])
exporter_id = request.POST.get("id", None)
if exporter_id is not None:
exporter = exporter_api.get_by_id(exporter_id)
template_id_list = [
template_api.get(template_id, request=request)
for template_id in templates
]
exporter.templates = template_id_list
exporter_api.upsert(exporter)
return HttpResponse(json.dumps({}),
content_type="application/javascript")
else:
return HttpResponseBadRequest("Bad entries. Please check your entries")
def check_query_form(form_values, template_id, request=None):
"""Checks that values entered by the user match each element type
Args:
form_values:
template_id:
request:
Returns:
"""
template = template_api.get(template_id, request=request)
namespaces = get_namespaces(template.content)
default_prefix = get_default_prefix(namespaces)
# check if there are no errors in the query
errors = []
if len(form_values) == 0:
errors.append("The query is empty.")
for field in form_values:
element_value = get_element_value(field)
element_name = field.get("name", "Unnamed field")
element_type = field.get("type", None)
# If there is a type to check
if element_type:
error = validate_element_value(
element_name, element_type, element_value, default_prefix
)
if error is not None:
errors.append(error)
return errors
def get(self, request, *args, **kwargs):
""" GET request. Create/Show the form for the configuration.
Args:
request:
*args:
**kwargs:
Returns:
"""
template_id = kwargs.pop('template_id')
# Get the template
template = template_api.get(template_id)
# Get template information (version)
version_manager = version_manager_api.get_from_version(template)
version_number = version_manager_api.get_version_number(
version_manager, template_id)
try:
# Get the existing configuration to build the form
template_xsl_rendering = template_xsl_rendering_api.get_by_template_id(
template_id)
data = {
'id':
template_xsl_rendering.id,
'template':
template.id,
'list_xslt':
template_xsl_rendering.list_xslt.id
if template_xsl_rendering.list_xslt else None,
'detail_xslt':
template_xsl_rendering.detail_xslt.id
if template_xsl_rendering.detail_xslt else None
}
except (Exception, exceptions.DoesNotExist):
# If no configuration, new form with pre-selected fields.
data = {
'template': template.id,
'list_xslt': None,
'detail_xslt': None
}
self.context = {
'template_title':
version_manager.title,
'template_version':
version_number,
"form_template_xsl_rendering":
self.form_class(data),
'url_back_to':
reverse(self.back_to_url,
kwargs={'version_manager_id': version_manager.id})
}
return self.rendering(request,
self.template_name,
context=self.context,
assets=self.assets)
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 init_refinement_task(template_id):
"""Asynchronous tasks init refinement
Args:
template_id:
Returns:
"""
template = template_api.get(template_id)
init_refinements(template)
def add_template_metadata_format(metadata_prefix, template_id, request):
"""Add a new template metadata format.
Args:
metadata_prefix: Metadata Prefix.
template_id: Id of the template.
request:
Returns: Response.
"""
try:
template = template_api.get(template_id, request=request)
version_manager = version_manager_api.get_from_version(template,
request=request)
xml_schema = template.content
target_namespace = _get_target_namespace(xml_schema)
version_number = version_manager_api.get_version_number(
version_manager, template_id, request=request)
schema_url = _get_simple_template_metadata_format_schema_url(
version_manager.title, version_number)
obj = OaiProviderMetadataFormat(
metadata_prefix=metadata_prefix,
schema=schema_url,
xml_schema=xml_schema,
is_default=False,
is_template=True,
metadata_namespace=target_namespace,
template=template,
)
upsert(obj, request=request)
content = OaiPmhMessage.get_message_labelled(
"Metadata format added with success.")
return Response(content, status=status.HTTP_201_CREATED)
except oai_pmh_exceptions.OAIAPILabelledException as e:
raise e
except DoesNotExist:
raise oai_pmh_exceptions.OAIAPILabelledException(
message="Unable to add the new metadata format. "
"Impossible to retrieve the template with the "
"given template",
status_code=status.HTTP_404_NOT_FOUND,
)
except exceptions.XMLError as e:
raise oai_pmh_exceptions.OAIAPILabelledException(
message="Unable to add the new metadata format.%s" % str(e),
status_code=status.HTTP_400_BAD_REQUEST,
)
except Exception as e:
raise oai_pmh_exceptions.OAIAPILabelledException(
message="Unable to add the new metadata format.%s" % str(e),
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
)
def get_object(self, pk):
""" Get template from db
Args:
pk:
Returns:
"""
try:
return template_api.get(pk)
except exceptions.DoesNotExist:
raise Http404
def _get_current_template(request):
"""Get the current template.
Args:
request:
Returns:
"""
current_template_version = (
version_manager_api.get_active_global_version_manager_by_title(
REGISTRY_XSD_FILENAME, request=request))
current_template = template_api.get(current_template_version.current,
request=request)
return current_template
def test_template_get_returns_template(self, mock_get_by_id):
# Arrange
mock_template_filename = "Schema"
mock_template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>"
mock_template = _create_mock_template(mock_template_filename, mock_template_content)
mock_get_by_id.return_value = mock_template
# Act
result = template_api.get(mock_template.id)
# Assert
self.assertIsInstance(result, Template)
def get_current_registry_template():
""" Get the current template used for the registry.
Returns:
Template:
"""
try:
template_version = version_manager_api.\
get_active_global_version_manager_by_title(REGISTRY_XSD_FILENAME)
return template_api.get(
version_manager_api.get_current(template_version))
except Exception, e:
raise exceptions.ModelError(e.message)
def insert_sub_elements_query(request):
"""Inserts a query for a sub element in the query builder
Args:
request:
Returns:
"""
form_values = json.loads(request.POST["formValues"])
template_id = request.POST["templateID"]
criteria_id = request.POST["criteriaID"]
# get template
template = template_api.get(template_id, request=request)
# get template namespaces
namespaces = get_namespaces(template.content)
# get default prefix
default_prefix = get_default_prefix(namespaces)
# keep only selected fields
form_values = [field for field in form_values if field["selected"] is True]
errors = check_query_form(form_values, template_id, request=request)
if len(errors) == 0:
query = sub_elements_to_query(form_values, namespaces, default_prefix,
request)
displayed_query = sub_elements_to_pretty_query(form_values, namespaces,
request)
ui_id = "ui" + criteria_id[4:]
temporary_query = SavedQuery(
user_id=ExploreExampleAppConfig.name,
template=template,
query=json.dumps(query),
displayed_query=displayed_query,
)
saved_query_api.upsert(temporary_query)
response_dict = {
"criteriaID": criteria_id,
"prettyQuery": displayed_query,
"uiID": ui_id,
"queryID": str(temporary_query.id),
}
else:
return HttpResponseBadRequest("<br/>".join(errors),
content_type="application/javascript")
return HttpResponse(json.dumps(response_dict),
content_type="application/javascript")
def _get_current_template():
"""Get the current template.
Returns:
"""
current_template_version = (
version_manager_api.get_active_global_version_manager_by_title(
REGISTRY_XSD_FILENAME
)
)
current_template = template_api.get(
version_manager_api.get_current(current_template_version)
)
return current_template
def disable_template_version_from_version_manager(request):
""" Disable a template version of a version manager.
Args:
request:
Returns:
"""
try:
disable_version_of_version_manager(template_api.get(request.GET['id']))
except Exception, e:
return HttpResponseBadRequest(e.message,
content_type='application/javascript')
def _save_template_xslt(self, request):
"""Save a template xslt rendering.
Args:
request: Request.
"""
try:
# Get the list xslt instance
try:
list_xslt = xslt_transformation_api.get_by_id(
request.POST.get("list_xslt"))
except (Exception, exceptions.DoesNotExist):
list_xslt = None
# Get the list detail xslt instance
try:
list_detail_xslt = xslt_transformation_api.get_by_id_list(
request.POST.getlist("list_detail_xslt"))
except (Exception, exceptions.DoesNotExist):
list_detail_xslt = None
# Get the default detail xslt instance
try:
default_detail_xslt = xslt_transformation_api.get_by_id(
request.POST.get("default_detail_xslt"))
except (Exception, exceptions.DoesNotExist):
default_detail_xslt = None
template_xsl_rendering_api.add_or_delete(
template_xsl_rendering_id=request.POST.get("id"),
template_id=request.POST.get("template"),
list_xslt=list_xslt,
default_detail_xslt=default_detail_xslt,
list_detail_xslt=list_detail_xslt,
)
template = template_api.get(request.POST.get("template"),
request=request)
# Get template information (version)
version_manager = version_manager_api.get_from_version(
template, request=request)
return HttpResponseRedirect(
reverse(self.save_redirect, args=[version_manager.id]))
except Exception as e:
self.context.update({"errors": html_escape(str(e))})
return self.rendering(request,
self.template_name,
context=self.context)
def get_sub_elements_query_builder(request):
"""Build the form for queries on sub elements
Args:
request:
Returns:
"""
leaves_id = request.POST["leavesID"]
template_id = request.POST["templateID"]
# get list of ids from string
list_leaves_id = leaves_id.split(" ")
# get template
template = template_api.get(template_id, request=request)
# get template namespaces
namespaces = get_namespaces(template.content)
# get default prefix
default_prefix = get_default_prefix(namespaces)
# get the parent name using the first schema element of the list
parent_name = get_parent_name(list_leaves_id[0], namespaces, request)
form_fields = []
for leaf_id in list_leaves_id:
data_structure_element = data_structure_element_api.get_by_id(
leaf_id, request)
element_type = data_structure_element.options["type"]
element_name = data_structure_element.options["name"]
user_inputs = get_user_inputs(element_type, data_structure_element,
default_prefix)
form_fields.append({
"element_id": leaf_id,
"element_name": element_name,
"element_type": element_type,
"html": user_inputs,
})
response_dict = {
"subElementQueryBuilder":
render_sub_elements_query(parent_name, form_fields)
}
return HttpResponse(json.dumps(response_dict),
content_type="application/javascript")
def set_current_template_version_from_version_manager(request):
""" Set the current version of a template.
Args:
request:
Returns:
"""
try:
set_current_version_from_version_manager(
template_api.get(request.GET['id']))
except Exception, e:
return HttpResponseBadRequest(e.message,
content_type='application/javascript')
