def _save_type_version(request, assets, context, type_version_manager):
"""Save a type version.
Args:
request:
assets:
context:
type_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:
type_object = Type(filename=xsd_file.name, content=xsd_data)
type_version_manager_api.insert(type_version_manager, type_object)
return HttpResponseRedirect(
reverse(
"admin:core_composer_app_manage_type_versions",
kwargs={'version_manager_id': str(type_version_manager.id)}))
except exceptions.XSDError, xsd_error:
return _handle_xsd_errors(request, assets, context, xsd_error,
xsd_data, xsd_file.name)
def _save_type_version(request, assets, context, type_version_manager):
"""Save a type version.
Args:
request:
assets:
context:
type_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:
type_object = Type(filename=xsd_file.name, content=xsd_data)
type_version_manager_api.insert(type_version_manager,
type_object,
request=request)
return HttpResponseRedirect(
reverse(
"admin:core_composer_app_manage_type_versions",
kwargs={"version_manager_id": str(type_version_manager.id)},
))
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_type_response(request, assets, context)
def _save_type(request, assets, context):
"""Save a type.
Args:
request:
assets:
context:
Returns:
"""
# get the schema name
name = request.POST['name']
# 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)
# get the buckets
buckets = request.POST.getlist('buckets')
try:
type_object = Type(filename=xsd_file.name, content=xsd_data)
type_version_manager = TypeVersionManager(title=name)
type_version_manager_api.insert(type_version_manager, type_object,
buckets)
return HttpResponseRedirect(reverse("admin:core_composer_app_types"))
except exceptions.XSDError, xsd_error:
return _handle_xsd_errors(request, assets, context, xsd_error,
xsd_data, xsd_file.name)
def save_type(request):
"""Save the current type in the database.
Args:
request:
Returns:
"""
try:
type_name = request.POST['typeName']
template_id = request.POST['templateID']
xsd_string = request.session['newXmlTemplateCompose']
response_dict = {}
# can save as type if new type or from existing type
if template_id != "new":
try:
# check if the type exists, raises exception otherise
type_api.get(template_id)
except:
# the type does not exist
return _error_response(
"Unable to save an existing template as a type.")
try:
# remove root from tree if present
xsd_string = composer_xml_utils.remove_single_root_element(
xsd_string)
# 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)
dependencies = _get_dependencies_ids(
request.session["includedTypesCompose"])
try:
# create type version manager
type_version_manager = TypeVersionManager(title=type_name,
user=str(
request.user.id))
# create type
type_object = Type(filename=type_name,
content=xsd_string,
dependencies=dependencies)
# save type in database
type_version_manager_api.insert(type_version_manager, type_object)
except exceptions.NotUniqueError, e:
return HttpResponseBadRequest(
"A type with the same name already exists. Please choose another name."
)
def _save_type(request, assets, context):
"""Save a type.
Args:
request:
assets:
context:
Returns:
"""
try:
# get the schema name
name = request.POST["name"]
# 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)
# get the buckets
buckets = request.POST.getlist("buckets")
type_object = Type(filename=xsd_file.name, content=xsd_data)
type_version_manager = TypeVersionManager(title=name)
type_version_manager_api.insert(type_version_manager,
type_object,
request=request,
list_bucket_ids=buckets)
return HttpResponseRedirect(reverse("admin:core_composer_app_types"))
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_type_response(request, assets, context)
def create(self, validated_data):
"""
Create and return a new `Type` instance, given the validated data.
"""
type_object = Type(
filename=validated_data["filename"],
content=validated_data["content"],
user=validated_data["user"],
)
type_version_manager_object = validated_data["type_version_manager"]
# load dependencies
dependencies_dict = load_dependencies(validated_data)
# Update the content of the template with dependencies
init_template_with_dependencies(type_object,
dependencies_dict,
request=self.context["request"])
# Create the template and its template version manager
type_version_manager_api.insert(type_version_manager_object,
type_object,
request=self.context["request"])
return type_object
def test_create_version_manager_raises_exception_if_error_in_create_type(self, mock_save):
# Arrange
type_filename = "schema.xsd"
type_object = _create_type(type_filename)
mock_version_manager = _create_mock_type_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, type_object)
def test_create_version_manager_raises_exception_if_error_in_create_version_manager(self, mock_save,
mock_save_version_manager,
mock_delete):
# Arrange
type_filename = "Schema"
type_object = _create_type(type_filename)
mock_save.return_value = type_object
version_manager = _create_type_version_manager(title="Schema")
mock_save_version_manager.side_effect = django_exceptions.ValidationError("")
mock_delete.return_value = None
# Act + Assert
with self.assertRaises(ModelError):
version_manager_api.insert(version_manager, type_object)
def test_insert_manager_raises_api_error_if_title_already_exists(self, mock_version_manager_save,
mock_save,
mock_delete):
# Arrange
type_filename = "schema.xsd"
type_object = _create_type(type_filename)
mock_save.return_value = type_object
mock_delete.return_value = None
mock_version_manager = _create_type_version_manager(title="Schema")
mock_version_manager_save.side_effect = mongoengine_exceptions.NotUniqueError
# Act + Assert
with self.assertRaises(NotUniqueError):
version_manager_api.insert(mock_version_manager, type_object)
def test_create_version_manager_raises_exception_if_type_not_supported(self, mock_save_type,
mock_save_type_version_manager):
# Arrange
type_filename = "schema.xsd"
type_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>"
type_object = _create_type(type_filename, type_content)
mock_save_type.return_value = type_object
version_manager = _create_type_version_manager(title="Schema")
mock_save_type_version_manager.return_value = version_manager
# Act + Assert
with self.assertRaises(CoreError):
version_manager_api.insert(version_manager, type_object)
def create(self, validated_data):
"""
Create and return a new `Type` instance, given the validated data.
"""
type_object = Type(filename=validated_data['filename'],
content=validated_data['content'])
type_version_manager_object = validated_data['type_version_manager']
# load dependencies
dependencies_dict = load_dependencies(validated_data)
# Update the content of the template with dependencies
init_template_with_dependencies(type_object, dependencies_dict)
# Create the template and its template version manager
type_version_manager_api.insert(type_version_manager_object, type_object)
return type_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[]")
buckets = request.POST.getlist("buckets[]")
# create new object
type_object = Type(filename=filename,
content=_get_xsd_content_from_html(xsd_content))
init_template_with_dependencies(
type_object,
_get_dependencies_dict(schema_locations, dependencies),
request=request,
)
# get the version manager or create a new one
if version_manager_id != "":
type_version_manager = version_manager_api.get(version_manager_id,
request=request)
else:
type_version_manager = TypeVersionManager(title=name)
type_version_manager_api.insert(type_version_manager,
type_object,
request=request,
list_bucket_ids=buckets)
except Exception as e:
return HttpResponseBadRequest(escape(str(e)),
content_type="application/javascript")
return HttpResponse(json.dumps({}), content_type="application/javascript")
def _set_xsd_type(xsd_filename, xsd_data):
"""Register XSD type to Django.
Args:
xsd_filename:
xsd_data:
Returns:
"""
try:
type_object = Type(filename=xsd_filename, content=xsd_data)
type_version_manager = TypeVersionManager(title=xsd_filename)
type_version_manager_api.insert(type_version_manager, type_object)
logger.info("XSD type:" + xsd_filename + " registered as as type.")
except exceptions.CoreError as e:
logger.info(xsd_filename + " didn't registered as a type :" + str(e))
except exceptions.NotUniqueError as e:
logger.info(xsd_filename + " didn't registered as a type :" + str(e))
except Exception as e:
logger.info(xsd_filename + " didn't registered as a type :" + str(e))
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[]')
buckets = request.POST.getlist('buckets[]')
# create new object
type_object = Type(filename=filename,
content=_get_xsd_content_from_html(xsd_content))
init_template_with_dependencies(
type_object, _get_dependencies_dict(schema_locations,
dependencies))
# get the version manager or create a new one
if version_manager_id != '':
type_version_manager = version_manager_api.get(version_manager_id)
else:
type_version_manager = TypeVersionManager(title=name)
type_version_manager_api.insert(type_version_manager, type_object,
buckets)
except Exception, e:
return HttpResponseBadRequest(e.message,
content_type='application/javascript')
def test_create_version_manager_returns_version_manager(self, mock_save_type,
mock_save_type_version_manager):
# Arrange
type_filename = "schema.xsd"
type_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'><simpleType name='type'>" \
"<restriction base='string'><enumeration value='test'/></restriction>" \
"</simpleType></schema>"
type_object = _create_type(type_filename, type_content)
mock_save_type.return_value = type_object
version_manager = _create_type_version_manager(title="Schema")
mock_save_type_version_manager.return_value = version_manager
# Act
result = version_manager_api.insert(version_manager, type_object)
# Assert
self.assertIsInstance(result, TypeVersionManager)
def save_type(request):
"""Save the current type in the database.
Args:
request:
Returns:
"""
try:
type_name = request.POST["typeName"]
template_id = request.POST["templateID"]
xsd_string = request.session["newXmlTemplateCompose"]
response_dict = {}
# can save as type if new type or from existing type
if template_id != "new":
try:
# check if the type exists, raises exception otherwise
type_api.get(template_id, request=request)
except Exception as e:
# the type does not exist
logger.warning("save_type threw an exception: {0}".format(
str(e)))
return _error_response(
"Unable to save an existing template as a type.")
try:
# remove root from tree if present
xsd_string = composer_xml_utils.remove_single_root_element(
xsd_string)
# 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. " + str(e))
dependencies = _get_dependencies_ids(
request.session["includedTypesCompose"], request=request)
try:
# create type version manager
type_version_manager = TypeVersionManager(title=type_name,
user=str(
request.user.id))
# create type
type_object = Type(
filename=type_name,
content=xsd_string,
dependencies=dependencies,
user=str(request.user.id),
)
# save type in database
type_version_manager_api.insert(type_version_manager,
type_object,
request=request)
except exceptions.NotUniqueError:
return HttpResponseBadRequest(
"A type 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")